Configuración de las tablas de DynamoDB Creando tu GraphQL API Definir una publicación básica API Configuración del origen de datos para las tablas de DynamoDB Configuración del addPost solucionador (DynamoDB) PutItem Configuración del getPost solucionador (DynamoDB) GetItem Crear una updatePost mutación (DynamoDB) UpdateItem Modificación del updatePost solucionador (DynamoDB) UpdateItem Creación upvotePost y downvotePost mutaciones (DynamoDB) UpdateItem Configuración del deletePost solucionador (DynamoDB) DeleteItem Configuración del allPost solucionador (DynamoDB Scan)Configuración del allPostsBy Author Resolver (consulta de DynamoDB)Uso de conjuntos Uso de listas y mapas Conclusión

Creación de una aplicación posterior sencilla con resolutores de DynamoDB

nota

Ahora admitimos principalmente el tiempo de ejecución APPSYNC _JS y su documentación. Considere la posibilidad de utilizar el motor de ejecución APPSYNC _JS y sus guías aquí.

En este tutorial se muestra cómo puede incorporar sus propias tablas de Amazon DynamoDB y conectarlas AWS AppSync a un GraphQL. API

Puede permitir el AWS AppSync aprovisionamiento de recursos de DynamoDB en su nombre. O bien, si lo prefiere, puede conectar las tablas existentes a un esquema de GraphQL creando un origen de datos y un solucionador. En cualquier caso, podrá leer y escribir en la base de datos de DynamoDB a través de instrucciones de GraphQL y suscribirse a datos en tiempo real.

Hay que realizar una serie de pasos de configuración específicos para que las instrucciones de GraphQL se traduzcan a operaciones de DynamoDB y que, a su vez, las respuestas se traduzcan de nuevo a GraphQL. En este tutorial se describe el proceso de configuración a través de varios escenarios y patrones de acceso a datos del mundo real.

Configuración de las tablas de DynamoDB

Para comenzar este tutorial, primero debe seguir los pasos que se indican a continuación para AWS aprovisionar los recursos.

AWS Aprovisione los recursos mediante la siguiente AWS CloudFormation plantilla enCLI:
```
aws cloudformation create-stack \
    --stack-name AWSAppSyncTutorialForAmazonDynamoDB \
    --template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml \
    --capabilities CAPABILITY_NAMED_IAM
```
Como alternativa, puedes lanzar la siguiente AWS CloudFormation pila en la región US-West 2 (Oregón) de tu AWS cuenta.

Así se crea lo siguiente:
- Una tabla de DynamoDB llamada AppSyncTutorial-Post que contendrá datos de Post.
- Un IAM rol y una política IAM gestionada asociada AWS AppSync para poder interactuar con la Post tabla.
Para ver más detalles sobre la pila y los recursos creados, ejecuta el siguiente CLI comando:
```
aws cloudformation describe-stacks --stack-name AWSAppSyncTutorialForAmazonDynamoDB
```

Para eliminar los recursos más adelante, puede ejecutar lo siguiente:


aws cloudformation delete-stack --stack-name AWSAppSyncTutorialForAmazonDynamoDB

Creando tu GraphQL API

Para crear GraphQL API en: AWS AppSync

Inicia sesión en la AppSync consola AWS Management Console y ábrela.
1. En el APIspanel de control, selecciona Crear API.
En la ventana Personalice API o importe desde Amazon DynamoDB, seleccione Crear desde cero.
1. Seleccione Comenzar a la derecha de la misma ventana.
En el campo de APInombre, defina el nombre del API to. AWSAppSyncTutorial
Seleccione Crear.

La AWS AppSync consola crea un nuevo GraphQL API para usted mediante el modo de autenticación de API claves. Puedes usar la consola para configurar el resto de GraphQL API y ejecutar consultas en él durante el resto de este tutorial.

Definir una publicación básica API

Ahora que ha creado un AWS AppSync GraphQLAPI, puede configurar un esquema básico que permita la creación, recuperación y eliminación básicas de los datos posteriores.

Inicia sesión en la consola AWS Management Console y ábrelaAppSync .
1. En el APIspanel de control, elige el API que acabas de crear.

En la barra lateral, seleccione Esquema.

En la página Esquema, sustituya el contenido por el código siguiente:


schema {
    query: Query
    mutation: Mutation
}

type Query {
    getPost(id: ID): Post
}

type Mutation {
    addPost(
        id: ID!
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

type Post {
    id: ID!
    author: String
    title: String
    content: String
    url: String
    ups: Int!
    downs: Int!
    version: Int!
}

Seleccione Guardar.

Este esquema define un tipo Post y las operaciones para agregar y obtener objetos Post.

Configuración del origen de datos para las tablas de DynamoDB

A continuación, vincule las consultas y las mutaciones definidas en el esquema a la tabla AppSyncTutorial-Post de DynamoDB.

En primer lugar, AWS AppSync debe conocer sus tablas. Para ello, debe configurar una fuente de datos en AWS AppSync:

Inicie sesión en la AppSync consola AWS Management Console y ábrala.
1. En el APIspanel de control, elige tu GraphQLAPI.
2. En la barra lateral, seleccione Origen de datos.
Elija Crear origen de datos.
1. En Nombre de origen de datos, escriba PostDynamoDBTable.
2. En Tipo de origen de datos, elija Tabla de Amazon DynamoDB.
3. Para la región, selecciona US- WEST -2.
4. En Nombre de tabla, elija la tabla AppSyncTutorial-Post DynamoDB.
5. Cree un IAM rol nuevo (recomendado) o elija un rol existente que tenga el permiso. lambda:invokeFunction IAM Los roles existentes necesitan una política de confianza, tal y como se explica en la sección Asociar un origen de datos.
  
  El siguiente es un ejemplo IAM de política que tiene los permisos necesarios para realizar operaciones en el recurso:
```
{ 
     "Version": "2012-10-17", 
     "Statement": [ 
         { 
             "Effect": "Allow", 
             "Action": [ "lambda:invokeFunction" ], 
             "Resource": [ 
                 "arn:aws:lambda:us-west-2:123456789012:function:myFunction", 
                 "arn:aws:lambda:us-west-2:123456789012:function:myFunction:*" 
             ] 
         } 
     ] 
 }
```
Seleccione Crear.

Configuración del addPost solucionador (DynamoDB) PutItem

Una vez AWS AppSync que conozca la tabla de DynamoDB, podrá vincularla a consultas y mutaciones individuales definiendo Resolvers. El primer solucionador que va a crear es addPost, que le permite crear una publicación en la tabla AppSyncTutorial-Post de DynamoDB.

Un solucionador tiene los siguientes componentes:

La ubicación en el esquema de GraphQL donde se asocia el solucionador. En este caso configuramos en el campo addPost un solucionador de tipo Mutation. El solucionador se invocará cuando el intermediario llame a mutation { addPost(...){...} }.
El origen de datos que se va a utilizar para el solucionador. En este caso, queremos utilizar el origen de datos PostDynamoDBTable definido anteriormente para poder agregar entradas en la tabla AppSyncTutorial-Post de DynamoDB.
La plantilla de mapeo de solicitudes. El propósito de la plantilla de mapeo de solicitudes es tomar la solicitud entrante de la persona que llama y traducirla en instrucciones AWS AppSync para su ejecución en DynamoDB.
La plantilla de mapeo de respuestas. El cometido de la plantilla de mapeo de respuesta es tomar la respuesta de DynamoDB y traducirla de nuevo a algo que GraphQL espera. Esto resulta útil si la forma de los datos en DynamoDB es diferente del tipo Post en GraphQL. Como este caso sí tienen la misma forma, solo hay que transmitir los datos.

Para configurar el solucionador de :

Inicie sesión en la consola AWS Management Console y ábrala. AppSync
1. En el APIspanel de control, elige tu GraphQLAPI.
2. En la barra lateral, seleccione Origen de datos.
Elija Crear origen de datos.
1. En Nombre de origen de datos, escriba PostDynamoDBTable.
2. En Tipo de origen de datos, elija Tabla de Amazon DynamoDB.
3. Para la región, selecciona US- WEST -2.
4. En Nombre de tabla, elija la tabla AppSyncTutorial-Post DynamoDB.
5. Cree un IAM rol nuevo (recomendado) o elija un rol existente que tenga el permiso. lambda:invokeFunction IAM Los roles existentes necesitan una política de confianza, tal y como se explica en la sección Asociar un origen de datos.
  
  El siguiente es un ejemplo IAM de política que tiene los permisos necesarios para realizar operaciones en el recurso:
```
{ 
     "Version": "2012-10-17", 
     "Statement": [ 
         { 
             "Effect": "Allow", 
             "Action": [ "lambda:invokeFunction" ], 
             "Resource": [ 
                 "arn:aws:lambda:us-west-2:123456789012:function:myFunction", 
                 "arn:aws:lambda:us-west-2:123456789012:function:myFunction:*" 
             ] 
         } 
     ] 
 }
```
Seleccione Crear.
Elija la pestaña Schema (Esquema).
En el panel de tipos de datos de la derecha, busque el addPostcampo correspondiente al tipo de mutación y, a continuación, seleccione Adjuntar.
En el menú Acción, selecciona Actualizar tiempo de ejecución y, a continuación, selecciona Unit Resolver (VTLsolo).
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.
En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:
```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "attributeValues" : {
        "author" : $util.dynamodb.toDynamoDBJson($context.arguments.author),
        "title" : $util.dynamodb.toDynamoDBJson($context.arguments.title),
        "content" : $util.dynamodb.toDynamoDBJson($context.arguments.content),
        "url" : $util.dynamodb.toDynamoDBJson($context.arguments.url),
        "ups" : { "N" : 1 },
        "downs" : { "N" : 0 },
        "version" : { "N" : 1 }
    }
}
```
Nota: se especifica un tipo para todas las claves y valores de atributos. Por ejemplo, puede establecer el campo author como { "S" : "${context.arguments.author}" }. La S parte indica a DynamoDB AWS AppSync y a DynamoDB que el valor será un valor de cadena. El valor real se rellena con el argumento author. Del mismo modo, el campo version es numérico, ya que utiliza N para el tipo. Por último, también inicializamos los campos ups, downs y version.

En este tutorial, especificó que el ID! tipo GraphQL, que indexa el nuevo elemento que se inserta en DynamoDB, forma parte de los argumentos del cliente. AWS AppSync viene con una utilidad para la generación automática de identificadores llamada$utils.autoId(), que también podrías haber utilizado en forma de. "id" : { "S" : "${$utils.autoId()}" } Así bastaría con excluir id: ID! de la definición del esquema de addPost() y se insertaría de forma automática. No utilizará esta técnica en este tutorial, pero debe considerarla, ya que se trata de una práctica recomendada a la hora de escribir en tablas de DynamoDB.

Para obtener más información acerca de las plantillas de mapeo, consulte la sección Información general de plantillas de mapeo de solucionador. Para obtener más información sobre el mapeo de GetItem solicitudes, consulte la documentación de GetItemreferencia. Para obtener más información sobre los tipos, consulte la documentación de referencia del Sistema de tipos (mapeos de solicitud).
En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```
Nota: Debido a que la forma de los datos de la tabla AppSyncTutorial-Post coincide exactamente con la forma del tipo Post de GraphQL, la plantilla de mapeo de respuesta se limita a pasar directamente los resultados. Observe que todos los ejemplos de este tutorial utilizan la misma plantilla de mapeo de respuesta, de manera que solo tiene que crear un archivo.
Seleccione Guardar.

APILlámalos para añadir una publicación

Ahora que el solucionador está configurado, AWS AppSync puede convertir una addPost mutación entrante en una operación de PutItem DynamoDB. Ahora puede ejecutar una mutación para incluir datos en la tabla.

Seleccione la pestaña Queries (Consultas).

En el panel Queries (Consultas), pegue la mutación siguiente:


mutation addPost {
  addPost(
    id: 123
    author: "AUTHORNAME"
    title: "Our first post!"
    content: "This is our first post."
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Los resultados de la publicación que acaba de crear deben aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "addPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our first post!",
      "content": "This is our first post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

Esto es lo que ha ocurrido:

AWS AppSync recibió una solicitud de addPost mutación.

AWS AppSync tomó la solicitud y la plantilla de mapeo de la solicitud y generó un documento de mapeo de la solicitud. Esto habrá tenido el siguiente aspecto:


{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key" : {
        "id" : { "S" : "123" }
    },
    "attributeValues" : {
        "author": { "S" : "AUTHORNAME" },
        "title": { "S" : "Our first post!" },
        "content": { "S" : "This is our first post." },
        "url": { "S" : "https://aws.amazon.com/appsync/" },
        "ups" : { "N" : 1 },
        "downs" : { "N" : 0 },
        "version" : { "N" : 1 }
    }
}

AWS AppSync utilizó el documento de mapeo de solicitudes para generar y ejecutar una solicitud de PutItem DynamoDB.

AWS AppSync tomó los resultados de la PutItem solicitud y los volvió a convertir a tipos GraphQL.


{
    "id" : "123",
    "author": "AUTHORNAME",
    "title": "Our first post!",
    "content": "This is our first post.",
    "url": "https://aws.amazon.com/appsync/",
    "ups" : 1,
    "downs" : 0,
    "version" : 1
}

Después los ha pasado a través del documento de mapeo de respuesta, que se ha limitado a transferirlos sin cambios.
Por fin ha devuelto el objeto recién creado en la respuesta de GraphQL.

Configuración del getPost solucionador (DynamoDB) GetItem

Ahora que puede añadir datos a la tabla de DynamoDB AppSyncTutorial-Post, tiene que configurar la consulta getPost para poder recuperar los datos de la tabla AppSyncTutorial-Post. Para ello, tiene que configurar otro solucionador.

Elija la pestaña Schema (Esquema).
En el panel de tipos de datos de la derecha, busque el getPostcampo en el tipo de consulta y, a continuación, seleccione Adjuntar.
En el menú Acción, selecciona Actualizar tiempo de ejecución y, a continuación, selecciona Unit Resolver (VTLsolo).
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:


{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    }
}

En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```
Seleccione Guardar.

APILlámalos para obtener una publicación

Ahora que el solucionador está configurado, AWS AppSync sabe cómo convertir una getPost consulta entrante en una operación de GetItem DynamoDB. Ahora puede ejecutar una consulta para recuperar la publicación que ha creado anteriormente.

Seleccione la pestaña Queries (Consultas).

En el panel Queries (Consultas), pegue lo siguiente:


query getPost {
  getPost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

La publicación obtenida de DynamoDB debe aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "getPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our first post!",
      "content": "This is our first post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

Esto es lo que ha ocurrido:

AWS AppSync recibió una getPost solicitud de consulta.
AWS AppSync tomó la solicitud y la plantilla de mapeo de solicitudes y generó un documento de mapeo de solicitudes. Esto habrá tenido el siguiente aspecto:
```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "id" : { "S" : "123" }
    }
}
```
AWS AppSync utilizó el documento de mapeo de solicitudes para generar y ejecutar una solicitud de GetItem DynamoDB.

AWS AppSync tomó los resultados de la GetItem solicitud y los volvió a convertir a tipos GraphQL.


{
    "id" : "123",
    "author": "AUTHORNAME",
    "title": "Our first post!",
    "content": "This is our first post.",
    "url": "https://aws.amazon.com/appsync/",
    "ups" : 1,
    "downs" : 0,
    "version" : 1
}

Después los ha pasado a través del documento de mapeo de respuesta, que se ha limitado a transferirlos sin cambios.
Entonces ha devuelto el objeto recuperado en la respuesta.

Como alternativa, vamos a tomar el siguiente ejemplo:


query getPost {
  getPost(id:123) {
    id
    author
    title
  }
}

Si la consulta getPost solo necesita las letras id, author y title, puede cambiar la plantilla de mapeo de solicitudes para utilizar expresiones de proyección que especifiquen únicamente los atributos que desee de la tabla de DynamoDB y evitar la transferencia innecesaria de datos de DynamoDB a AWS AppSync. Por ejemplo, la plantilla de mapeo de solicitudes puede tener un aspecto similar al siguiente fragmento:


{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    },
    "projection" : {
     "expression" : "#author, id, title",
     "expressionNames" : { "#author" : "author"}
    }
}

Crear una updatePost mutación (DynamoDB) UpdateItem

De momento ya sabe crear y recuperar objetos Post en DynamoDB. A continuación va a configurar una nueva mutación que permite actualizar objetos. Para ello, utilice la operación UpdateItem DynamoDB.

Elija la pestaña Schema (Esquema).

En el panel Schema (Esquema) modifique el tipo Mutation para agregar una nueva mutación updatePost de este modo:


type Mutation {
    updatePost(
        id: ID!,
        author: String!,
        title: String!,
        content: String!,
        url: String!
    ): Post
    addPost(
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

Seleccione Guardar.
En el panel de tipos de datos de la derecha, busque el updatePostcampo recién creado en el tipo de mutación y, a continuación, seleccione Adjuntar.
En el menú Acción, selecciona Actualizar tiempo de ejecución y, a continuación, selecciona Unit Resolver (VTLsolo).
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.
En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:
```
{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "SET author = :author, title = :title, content = :content, #url = :url ADD version :one",
        "expressionNames": {
            "#url" : "url"
        },
        "expressionValues": {
            ":author" : $util.dynamodb.toDynamoDBJson($context.arguments.author),
            ":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title),
            ":content" : $util.dynamodb.toDynamoDBJson($context.arguments.content),
            ":url" : $util.dynamodb.toDynamoDBJson($context.arguments.url),
            ":one" : { "N": 1 }
        }
    }
}
```
Nota: Este solucionador utiliza UpdateItem DynamoDB, que es muy diferente de la operación. PutItem En lugar de escribir el elemento completo, solo pide a DynamoDB que actualice determinados atributos. Esto se consigue mediante expresiones de actualización de DynamoDB. La expresión en sí se especifica en el campo expression de la sección update. Indica que se deben establecer los atributos author, title, content y URL, y a continuación incrementar el campo version. Los valores empleados no aparecen en la expresión en sí, que contiene marcadores de posición con nombres que comienzan con dos puntos y que luego se definen en el campo expressionValues. Por último, DynamoDB tiene palabras reservadas que no pueden aparecer en la expression. Por ejemplo, url es una palabra reservada, por lo que para actualizar el campo url, puede utilizar marcadores de posición de nombre y definirlos en el campo expressionNames.

Para obtener más información sobre el mapeo de UpdateItem solicitudes, consulte la documentación de UpdateItemreferencia. Para obtener más información sobre cómo escribir expresiones de actualización, consulte la documentación de UpdateExpressions DynamoDB.
En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```

Llámelos API para actualizar una publicación

Ahora que el solucionador está configurado, AWS AppSync sabe cómo traducir una update mutación entrante en una operación de Update DynamoDB. Ahora puede ejecutar una mutación para actualizar el elemento que escribió anteriormente.

Seleccione la pestaña Queries (Consultas).

En el panel Queries (Consultas), pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente.


mutation updatePost {
  updatePost(
    id:"123"
    author: "A new author"
    title: "An updated author!"
    content: "Now with updated content!"
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

La publicación actualizada en DynamoDB debería aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "updatePost": {
      "id": "123",
      "author": "A new author",
      "title": "An updated author!",
      "content": "Now with updated content!",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 2
    }
  }
}

En este ejemplo, los downs campos ups y no se modificaron porque la plantilla de mapeo de solicitudes no pedía AWS AppSync a DynamoDB que hiciera nada con esos campos. Además, el version campo se incrementó en 1 porque pidió AWS AppSync a DynamoDB que añadiera 1 al campo. version

Modificación del updatePost solucionador (DynamoDB) UpdateItem

Se trata de un buen comienzo para la mutación updatePost, pero tiene dos inconvenientes:

Aunque solo desee actualizar un campo, tiene que actualizar todos.
Si dos personas modifican el objeto a la vez información podría perderse información.

Para solucionar estos problemas, va a modificar la mutación updatePost de manera que únicamente modifique los argumentos que se han especificado en la solicitud, y también va a agregar una condición a la operación UpdateItem.

Elija la pestaña Schema (Esquema).
En el panel Schema (Esquema), modifique el campo updatePost del tipo Mutation para eliminar los signos de admiración de los argumentos author, title, content y url, asegurándose de dejar sin cambios el campo id. Esto los convertirá en argumentos opcionales. Además, añada un nuevo argumento expectedVersion obligatorio.
```
type Mutation {
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    addPost(
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}
```
Seleccione Guardar.
En el panel de tipos de datos de la derecha, busque el updatePostcampo correspondiente al tipo de mutación.
Seleccione PostDynamoDBTableabrir la resolución existente.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), modifique la plantilla de mapeo de solicitud de este modo:


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },

    ## Set up some space to keep track of things you're updating **
    #set( $expNames  = {} )
    #set( $expValues = {} )
    #set( $expSet = {} )
    #set( $expAdd = {} )
    #set( $expRemove = [] )

    ## Increment "version" by 1 **
    $!{expAdd.put("version", ":one")}
    $!{expValues.put(":one", { "N" : 1 })}

    ## Iterate through each argument, skipping "id" and "expectedVersion" **
    #foreach( $entry in $context.arguments.entrySet() )
        #if( $entry.key != "id" && $entry.key != "expectedVersion" )
            #if( (!$entry.value) && ("$!{entry.value}" == "") )
                ## If the argument is set to "null", then remove that attribute from the item in DynamoDB **

                #set( $discard = ${expRemove.add("#${entry.key}")} )
                $!{expNames.put("#${entry.key}", "$entry.key")}
            #else
                ## Otherwise set (or update) the attribute on the item in DynamoDB **

                $!{expSet.put("#${entry.key}", ":${entry.key}")}
                $!{expNames.put("#${entry.key}", "$entry.key")}
                $!{expValues.put(":${entry.key}", { "S" : "${entry.value}" })}
            #end
        #end
    #end

    ## Start building the update expression, starting with attributes you're going to SET **
    #set( $expression = "" )
    #if( !${expSet.isEmpty()} )
        #set( $expression = "SET" )
        #foreach( $entry in $expSet.entrySet() )
            #set( $expression = "${expression} ${entry.key} = ${entry.value}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Continue building the update expression, adding attributes you're going to ADD **
    #if( !${expAdd.isEmpty()} )
        #set( $expression = "${expression} ADD" )
        #foreach( $entry in $expAdd.entrySet() )
            #set( $expression = "${expression} ${entry.key} ${entry.value}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Continue building the update expression, adding attributes you're going to REMOVE **
    #if( !${expRemove.isEmpty()} )
        #set( $expression = "${expression} REMOVE" )

        #foreach( $entry in $expRemove )
            #set( $expression = "${expression} ${entry}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Finally, write the update expression into the document, along with any expressionNames and expressionValues **
    "update" : {
        "expression" : "${expression}"
        #if( !${expNames.isEmpty()} )
            ,"expressionNames" : $utils.toJson($expNames)
        #end
        #if( !${expValues.isEmpty()} )
            ,"expressionValues" : $utils.toJson($expValues)
        #end
    },

    "condition" : {
        "expression"       : "version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : $util.dynamodb.toDynamoDBJson($context.arguments.expectedVersion)
        }
    }
}

Seleccione Guardar.

Esta plantilla es uno de los ejemplos más complejos. Demuestra la eficacia y flexibilidad de las plantillas de mapeo. Itera por todos los argumentos, saltando id y expectedVersion. Si el argumento tiene un valor determinado, pide AWS AppSync a DynamoDB que actualice ese atributo en el objeto de DynamoDB. Si el atributo se establece en null, pide AWS AppSync a DynamoDB que elimine ese atributo del objeto de publicación. Si no se ha especificado algún argumento, lo dejará como está. También incrementa el campo version.

También hay una nueva sección condition. Una expresión de condición permite indicar AWS AppSync a DynamoDB si la solicitud debe realizarse correctamente o no en función del estado del objeto que ya se encuentra en DynamoDB antes de realizar la operación. En este caso, solo quiere que la solicitud UpdateItem se realice si el campo version del elemento que hay en DynamoDB coincide exactamente con el argumento expectedVersion.

Si desea más información sobre las expresiones de condición, consulte la documentación de referencia Expresiones de condición.

Llámelos para actualizar una publicación API

Vamos a intentar actualizar el objeto Post con el nuevo solucionador:

Seleccione la pestaña Queries (Consultas).

En el panel Queries (Consultas), pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente.


mutation updatePost {
  updatePost(
    id:123
    title: "An empty story"
    content: null
    expectedVersion: 2
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

La publicación actualizada en DynamoDB debería aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "updatePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 3
    }
  }
}

En esta solicitud, ha pedido a DynamoDB que actualice únicamente title el content campo AWS AppSync and. Los demás campos se quedan como estaban (salvo por el incremento del campo version). Hemos establecido un nuevo valor en el atributo title y hemos eliminado el atributo content de la publicación. Los campos author, url, ups y downs no se han modificado.

Intente ejecutar la solicitud de mutación de nuevo, dejándola exactamente como está. Verá una respuesta parecida a la siguiente:


{
  "data": {
    "updatePost": null
  },
  "errors": [
    {
      "path": [
        "updatePost"
      ],
      "data": {
        "id": "123",
        "author": "A new author",
        "title": "An empty story",
        "content": null,
        "url": "https://aws.amazon.com/appsync/",
        "ups": 1,
        "downs": 0,
        "version": 3
      },
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
    }
  ]
}

La solicitud falla porque la expresión de condición se evalúa como false:

La primera vez que ejecutamos la solicitud, el valor del campo version de la publicación en DynamoDB era 2, que coincidía con el argumento expectedVersion. La solicitud se realizó correctamente, lo que significa que el campo version se incrementó en DynamoDB a 3.
La segunda vez que ejecutamos la solicitud, el valor del campo version de la publicación en DynamoDB era 3, que no coincide con el argumento expectedVersion.

Este método suele denominarse "bloqueo optimista".

Una característica de un solucionador de AWS AppSync DynamoDB es que devuelve el valor actual del objeto post en DynamoDB. Puede encontrarlo en el campo data, en la sección errors de la respuesta de GraphQL. La aplicación puede utilizar esta información para decidir cómo debe proceder. En este caso, podemos ver que el campo version del objeto en DynamoDB tiene el valor 3, por lo que solo tendríamos que actualizar el argumento expectedVersion a 3 para que la solicitud se ejecutase de nuevo.

Para obtener más información sobre cómo gestionar los casos en que no se cumpla la condición, consulte Expresiones de condición en la documentación de referencia de las plantillas de mapeo.

Creación upvotePost y downvotePost mutaciones (DynamoDB) UpdateItem

El Post tipo tiene ups downs campos que permiten registrar los votos a favor y en contra, pero hasta ahora API no nos permite hacer nada con ellos. Vamos a agregar algunas mutaciones para votar a favor o en contra de las publicaciones.

Elija la pestaña Schema (Esquema).

En el panel Schema (Schema), modifique el tipo Mutation para agregar las nuevas mutaciones upvotePost y downvotePost, de este modo:


type Mutation {
    upvotePost(id: ID!): Post
    downvotePost(id: ID!): Post
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    addPost(
        author: String!,
        title: String!,
        content: String!,
        url: String!
    ): Post!
}

Seleccione Guardar.
En el panel de tipos de datos de la derecha, busca el upvotePostcampo recién creado en el tipo de mutación y, a continuación, selecciona Adjuntar.
En el menú Acción, selecciona Actualizar tiempo de ejecución y, a continuación, selecciona Unit Resolver (VTLsolo).
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "ADD ups :plusOne, version :plusOne",
        "expressionValues" : {
            ":plusOne" : { "N" : 1 }
        }
    }
}

En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```
Seleccione Guardar.
En el panel Data types (Tipos de datos) de la derecha, busque el campo downvotePost recién creado en el tipo Mutation y, a continuación, elija Attach (Asociar).
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "ADD downs :plusOne, version :plusOne",
        "expressionValues" : {
            ":plusOne" : { "N" : 1 }
        }
    }
}

En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```
Seleccione Guardar.

Llámalos a votar API a favor y a votar en contra de una publicación

Una vez configurados los nuevos resolutores, AWS AppSync sabe cómo traducir una operación entrante upvotePost o de downvote mutación a DynamoDB UpdateItem . Ahora puede ejecutar mutaciones para votar a favor o en contra de la publicación que ha creado anteriormente.

Seleccione la pestaña Queries (Consultas).
En el panel Queries (Consultas), pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente.
```
mutation votePost {
  upvotePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```
Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

La publicación se actualiza en DynamoDB y debe aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "upvotePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 0,
      "version": 4
    }
  }
}

Elija Execute query (Ejecutar consulta) algunas veces más. Debería ver cómo se incrementan en 1 los campos ups y version cada vez que ejecuta la consulta.

Modifique la consulta para llamar a la mutación downvotePost de este modo:


mutation votePost {
  downvotePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja). En esta ocasión, debería ver cómo se incrementan en 1 los campos downs y version cada vez que ejecuta la consulta.


{
  "data": {
    "downvotePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 4,
      "version": 12
    }
  }
}

Configuración del deletePost solucionador (DynamoDB) DeleteItem

La próxima mutación que desea configurar es la eliminación de una publicación. Para ello, utilizará la operación DeleteItem de DynamoDB.

Elija la pestaña Schema (Esquema).

En el panel Schema (Esquema) modifique el tipo Mutation para agregar una nueva mutación deletePost de este modo:


type Mutation {
    deletePost(id: ID!, expectedVersion: Int): Post
    upvotePost(id: ID!): Post
    downvotePost(id: ID!): Post
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    addPost(
        author: String!,
        title: String!,
        content: String!,
        url: String!
    ): Post!
}

Esta vez hemos declarado el campo expectedVersion como opcional, lo que se explica más adelante al añadir la plantilla de mapeo de solicitud.

Seleccione Guardar.
En el panel Data types (Tipos de datos) de la derecha, busque el campo delete recién creado en el tipo Mutation y, a continuación, elija Attach (Asociar).
En el menú Acción, seleccione Actualizar tiempo de ejecución y, a continuación, elija Unit Resolver (VTLsolo).
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.
En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:
```
{
    "version" : "2017-02-28",
    "operation" : "DeleteItem",
    "key": {
        "id": $util.dynamodb.toDynamoDBJson($context.arguments.id)
    }
    #if( $context.arguments.containsKey("expectedVersion") )
        ,"condition" : {
            "expression"       : "attribute_not_exists(id) OR version = :expectedVersion",
            "expressionValues" : {
                ":expectedVersion" : $util.dynamodb.toDynamoDBJson($context.arguments.expectedVersion)
            }
        }
    #end
}
```
Nota: el argumento expectedVersion es opcional. Si el intermediario ha establecido un argumento expectedVersion en la solicitud, entonces la plantilla añade una condición que solo permitirá que la solicitud DeleteItem se atienda cuando el elemento se haya eliminado o cuando el atributo version de la publicación en DynamoDB coincida exactamente con expectedVersion. Si se omite, no se especificará ninguna expresión de condición para la solicitud DeleteItem. Se realizará correctamente independientemente del valor de version o de si el elemento existe o no en DynamoDB.
En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```
Note: Aunque se trate de eliminar un elemento, puede devolver el elemento eliminado, siempre que no se haya eliminado previamente.
Seleccione Guardar.

Para obtener más información sobre el mapeo de DeleteItem solicitudes, consulta la documentación de DeleteItemreferencia.

APILlámalos para eliminar una publicación

Ahora que el solucionador está configurado, AWS AppSync sabe cómo traducir una delete mutación entrante en una operación de DeleteItem DynamoDB. Ahora ya podemos ejecutar una mutación para eliminar datos de la tabla.

Seleccione la pestaña Queries (Consultas).
En el panel Queries (Consultas), pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente.
```
mutation deletePost {
  deletePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```
Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

La publicación se elimina de DynamoDB. Tenga en cuenta que AWS AppSync devuelve el valor del elemento que se ha eliminado de DynamoDB, que debería aparecer en el panel de resultados a la derecha del panel de consulta. Debería parecerse a lo que sigue:


{
  "data": {
    "deletePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 4,
      "version": 12
    }
  }
}

El valor solo se devuelve si esta llamada a deletePost es realmente la que lo elimina de DynamoDB.

Elija Execute query (Ejecutar consulta) de nuevo.
La llamada se sigue ejecutando con éxito, pero no se devuelve ningún valor.
```
{
  "data": {
    "deletePost": null
  }
}
```

Ahora vamos a probar a eliminar una publicación, pero esta vez especificando expectedValue. Primero tiene que crear una nueva, porque acaba de eliminar la publicación con la que ha estado trabajando hasta ahora.

En el panel Queries (Consultas), pegue la mutación siguiente:


mutation addPost {
  addPost(
    id:123
    author: "AUTHORNAME"
    title: "Our second post!"
    content: "A new post."
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Los resultados de la publicación que acaba de crear deben aparecer en el panel de resultados a la derecha del panel de consultas. Anote el id del objeto recién creado, pues lo necesitaremos en breve. Debería parecerse a lo que sigue:


{
  "data": {
    "addPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our second post!",
      "content": "A new post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

Ahora intentaremos eliminar esta publicación, pero especificaremos un valor erróneo en expectedVersion:

En el panel Queries (Consultas), pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente.


mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 9999
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).


{
  "data": {
    "deletePost": null
  },
  "errors": [
    {
      "path": [
        "deletePost"
      ],
      "data": {
        "id": "123",
        "author": "AUTHORNAME",
        "title": "Our second post!",
        "content": "A new post.",
        "url": "https://aws.amazon.com/appsync/",
        "ups": 1,
        "downs": 0,
        "version": 1
      },
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
    }
  ]
}

La solicitud falla, porque la expresión de condición se evalúa como false: el valor de version de la publicación en DynamoDB no coincide con el expectedValue especificado en los argumentos. El valor actual del objeto se devuelve en el campo data de la sección errors de la respuesta de GraphQL.

Vuelva a intentar la solicitud, pero corrija expectedVersion:


mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 1
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Esta vez la solicitud se realiza correctamente y se devuelve el valor eliminado en DynamoDB:


{
  "data": {
    "deletePost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our second post!",
      "content": "A new post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

Elija Execute query (Ejecutar consulta) de nuevo.
La llamada sigue realizándose, pero esta vez no se devuelve ningún valor, ya que la publicación ya se había eliminado en DynamoDB.


{
  "data": {
    "deletePost": null
  }
}

Configuración del allPost solucionador (DynamoDB Scan)

Hasta ahora, solo API es útil si conoces cada publicación que quieres ver. id Añada un nuevo solucionador que devuelva todas las publicaciones en la tabla.

Elija la pestaña Schema (Esquema).

En el panel Schema (Esquema) modifique el tipo Query para agregar una nueva consulta allPost, de este modo:


type Query {
    allPost(count: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}

Añada un nuevo tipo PaginationPosts:


type PaginatedPosts {
    posts: [Post!]!
    nextToken: String
}

Seleccione Guardar.
En el panel de tipos de datos de la derecha, busca el allPostcampo recién creado en el tipo de consulta y, a continuación, selecciona Adjuntar.
En el menú Acción, selecciona Actualizar tiempo de ejecución y, a continuación, selecciona Unit Resolver (VTLsolo).
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.
En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:
```
{
    "version" : "2017-02-28",
    "operation" : "Scan"
    #if( ${context.arguments.count} )
        ,"limit": $util.toJson($context.arguments.count)
    #end
    #if( ${context.arguments.nextToken} )
        ,"nextToken": $util.toJson($context.arguments.nextToken)
    #end
}
```
Este solucionador tiene dos argumentos opcionales: count, que especifica el número máximo de elementos que se devolverán en una sola llamada, y nextToken, que se puede utilizar para recuperar el siguiente conjunto de resultados (más adelante mostrará de dónde procede el valor de nextToken).
En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
{
    "posts": $utils.toJson($context.result.items)
    #if( ${context.result.nextToken} )
        ,"nextToken": $util.toJson($context.result.nextToken)
    #end
}
```
Nota: esta plantilla de mapeo de respuesta es diferente de todas las que hemos visto hasta ahora. El resultado de la consulta allPost es del tipo PaginatedPosts, que contiene una lista de publicaciones y un token de paginación. La forma de este objeto es diferente a la que devuelve el AWS AppSync DynamoDB Resolver: items en los resultados del DynamoDB Resolver se consulta la lista de publicaciones, AWS AppSync pero se invoca. posts PaginatedPosts
Seleccione Guardar.

Si desea más información sobre el mapeo de solicitud Scan, consulte la documentación de referencia de Scan.

Llama al para escanear todas las publicaciones API

Ahora que el solucionador está configurado, AWS AppSync sabe cómo convertir una allPost consulta entrante en una operación de Scan DynamoDB. Ahora puede recorrer la tabla para obtener todas las publicaciones.

Sin embargo, antes de probarlo, debe rellenar la tabla datos, ya que hemos eliminado las publicaciones con las que hemos estado trabajado hasta ahora.

Seleccione la pestaña Queries (Consultas).

En el panel Queries (Consultas), pegue la mutación siguiente:


mutation addPost {
  post1: addPost(id:1 author: "AUTHORNAME" title: "A series of posts, Volume 1" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post2: addPost(id:2 author: "AUTHORNAME" title: "A series of posts, Volume 2" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post3: addPost(id:3 author: "AUTHORNAME" title: "A series of posts, Volume 3" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post4: addPost(id:4 author: "AUTHORNAME" title: "A series of posts, Volume 4" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post5: addPost(id:5 author: "AUTHORNAME" title: "A series of posts, Volume 5" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post6: addPost(id:6 author: "AUTHORNAME" title: "A series of posts, Volume 6" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post7: addPost(id:7 author: "AUTHORNAME" title: "A series of posts, Volume 7" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post8: addPost(id:8 author: "AUTHORNAME" title: "A series of posts, Volume 8" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post9: addPost(id:9 author: "AUTHORNAME" title: "A series of posts, Volume 9" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Ahora recorreremos la tabla obteniendo cinco resultados cada vez.

En el panel Queries (Consultas), pegue la siguiente consulta:


query allPost {
  allPost(count: 5) {
    posts {
      id
      title
    }
    nextToken
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Las cinco primeras publicaciones deben aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "allPost": {
      "posts": [
        {
          "id": "5",
          "title": "A series of posts, Volume 5"
        },
        {
          "id": "1",
          "title": "A series of posts, Volume 1"
        },
        {
          "id": "6",
          "title": "A series of posts, Volume 6"
        },
        {
          "id": "9",
          "title": "A series of posts, Volume 9"
        },
        {
          "id": "7",
          "title": "A series of posts, Volume 7"
        }
      ],
      "nextToken": "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRkJEdXdUK09hcnovRGhNTGxLTGdMUEFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF6ajFodkhKU1paT1pncTRaUUNBUkNBZ2dHWnJiR1dQWGxkMDB1N0xEdGY4Z2JsbktzRjRua1VCcks3TFJLcjZBTFRMeGFwVGJZMDRqOTdKVFQyYVRwSzdzbVdtNlhWWFVCTnFIOThZTzBWZHVkdDI2RlkxMHRqMDJ2QTlyNWJTUWpTbWh6NE5UclhUMG9KZWJSQ2JJbXBlaDRSVlg0Tis0WTVCN1IwNmJQWWQzOVhsbTlUTjBkZkFYMVErVCthaXZoNE5jMk50RitxVmU3SlJ5WmpzMEFkSGduM3FWd2VrOW5oeFVVd3JlK1loUks5QkRzemdiMDlmZmFPVXpzaFZ4cVJRbC93RURlOTcrRmVJdXZNby9NZ1F6dUdNbFRyalpNR3FuYzZBRnhwa0VlZTFtR0FwVDFISElUZlluakptYklmMGUzUmcxbVlnVHVSbDh4S0trNmR0QVoraEhLVDhuNUI3VnF4bHRtSnlNUXBrZGl6KzkyL3VzNDl4OWhrMnVxSW01ZFFwMjRLNnF0dm9ZK1BpdERuQTc5djhzb0grVytYT3VuQ2NVVDY4TVZ1Wk5KYkRuSEFSSEVlaTlVNVBTelU5RGZ6d2pPdmhqWDNJMWhwdWUrWi83MDVHVjlPQUxSTGlwZWZPeTFOZFhwZTdHRDZnQW00bUJUK2c1eC9Ec3ZDbWVnSDFDVXRTdHVuU1ZFa2JpZytQRC9oMUwyRTNqSHhVQldaa28yU256WUc0cG0vV1RSWkFVZHZuQT09In0="
    }
  }
}

Hemos obtenido cinco resultados y el valor nextToken, que nos permite obtener el siguiente conjunto de resultados.

Actualice la consulta allPost para incluir el valor de nextToken del conjunto de resultados anterior:


query allPost {
  allPost(
    count: 5
    nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRlluNktJRWl6V0ZlR3hJOVJkaStrZUFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5cW8yUGFSZThnalFpemRCTUNBUkNBZ2dHWk1JODhUNzhIOFVUZGtpdFM2ZFluSWRyVDg4c2lkN1RjZzB2d1k3VGJTTWpSQ2U3WjY3TkUvU2I1dWNETUdDMmdmMHErSGJSL0pteGRzYzVEYnE1K3BmWEtBdU5jSENJdWNIUkJ0UHBPWVdWdCtsS2U5L1pNcWdocXhrem1RaXI1YnIvQkt6dU5hZmJCdE93NmtoM2Jna1BKM0RjWWhpMFBGbmhMVGg4TUVGSjBCcXg3RTlHR1V5N0tUS0JLZlV3RjFQZ0JRREdrNzFYQnFMK2R1S2IrVGtZZzVYMjFrc3NyQmFVTmNXZmhTeXE0ZUJHSWhqZWQ5c3VKWjBSSTc2ZnVQdlZkR3FLNENjQmxHYXhpekZnK2pKK1FneEU1SXduRTNYYU5TR0I4QUpmamR2bU1wbUk1SEdvWjlMUUswclczbG14RDRtMlBsaTNLaEVlcm9pem5zcmdINFpvcXIrN2ltRDN3QkJNd3BLbGQzNjV5Nnc4ZnMrK2FnbTFVOUlKOFFrOGd2bEgySHFROHZrZXBrMWlLdWRIQ25LaS9USnBlMk9JeEVPazVnRFlzRTRUU09HUlVJTkxYY2MvdW1WVEpBMUthV2hWTlAvdjNlSnlZQUszbWV6N2h5WHVXZ1BkTVBNWERQdTdjVnVRa3EwK3NhbGZOd2wvSUx4bHNyNDVwTEhuVFpyRWZvVlV1bXZ5S2VKY1RUU1lET05hM1NwWEd2UT09In0="
  ) {
    posts {
      id
      author
    }
    nextToken
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Las cuatro publicaciones restantes deben aparecer en el panel de resultados a la derecha del panel de consultas. No hay ningún nextToken en este conjunto, porque ya ha recorrido las nueve publicaciones y no quedan más. Debería parecerse a lo que sigue:


{
  "data": {
    "allPost": {
      "posts": [
        {
          "id": "2",
          "title": "A series of posts, Volume 2"
        },
        {
          "id": "3",
          "title": "A series of posts, Volume 3"
        },
        {
          "id": "4",
          "title": "A series of posts, Volume 4"
        },
        {
          "id": "8",
          "title": "A series of posts, Volume 8"
        }
      ],
      "nextToken": null
    }
  }
}

Configuración del allPostsBy Author Resolver (consulta de DynamoDB)

Además de escanear DynamoDB para obtener todas las publicaciones, también puede consultar DynamoDB para obtener las publicaciones creadas por un autor determinado. La tabla de DynamoDB que creó anteriormente ya tiene un GlobalSecondaryIndex llamado author-index que puede utilizar con una operación Query de DynamoDB para recuperar todas las publicaciones creadas por un autor determinado.

Elija la pestaña Schema (Esquema).
En el panel Schema (Esquema) modifique el tipo Query para agregar una nueva consulta allPostsByAuthor, de este modo:
```
type Query {
    allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts!
    allPost(count: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}
```
Nota: aquí vuelve a usarse el tipo PaginatedPosts que empleamos en la consulta allPost.
Seleccione Guardar.
En el panel de tipos de datos de la derecha, busque el campo allPostsByAutor recién creado en el tipo de consulta y, a continuación, seleccione Adjuntar.
En el menú Acción, selecciona Actualizar tiempo de ejecución y, a continuación, selecciona Unit Resolver (VTLsolo).
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:


{
    "version" : "2017-02-28",
    "operation" : "Query",
    "index" : "author-index",
    "query" : {
      "expression": "author = :author",
        "expressionValues" : {
          ":author" : $util.dynamodb.toDynamoDBJson($context.arguments.author)
        }
    }
    #if( ${context.arguments.count} )
        ,"limit": $util.toJson($context.arguments.count)
    #end
    #if( ${context.arguments.nextToken} )
        ,"nextToken": "${context.arguments.nextToken}"
    #end
}

Al igual que el solucionador allPost, este solucionador tiene dos argumentos opcionales: count, que especifica el número máximo de elementos que se devolverá en una sola llamada, y nextToken, que se puede utilizar para recuperar el siguiente conjunto de resultados (el valor para nextToken se puede obtener en una llamada anterior).

En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
{
    "posts": $utils.toJson($context.result.items)
    #if( ${context.result.nextToken} )
        ,"nextToken": $util.toJson($context.result.nextToken)
    #end
}
```
Nota: esta es la misma plantilla de mapeo de respuesta que usamos en el solucionador allPost.
Seleccione Guardar.

Si desea más información sobre el mapeo de solicitud Query, consulte la documentación de referencia de Query.

Llámalo API para consultar todas las publicaciones de un autor

Ahora que el solucionador está configurado, AWS AppSync sabe cómo traducir una allPostsByAuthor mutación entrante en una operación de Query DynamoDB contra el índice. author-index Ahora puede consultar la tabla para recuperar todas las publicaciones de un autor determinado.

Sin embargo, antes de hacerlo, debemos rellenar la tabla con algunas publicaciones más, ya que por el momento todas son del mismo autor.

Seleccione la pestaña Queries (Consultas).

En el panel Queries (Consultas), pegue la mutación siguiente:


mutation addPost {
  post1: addPost(id:10 author: "Nadia" title: "The cutest dog in the world" content: "So cute. So very, very cute." url: "https://aws.amazon.com/appsync/" ) { author, title }
  post2: addPost(id:11 author: "Nadia" title: "Did you know...?" content: "AppSync works offline?" url: "https://aws.amazon.com/appsync/" ) { author, title }
  post3: addPost(id:12 author: "Steve" title: "I like GraphQL" content: "It's great" url: "https://aws.amazon.com/appsync/" ) { author, title }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Ahora consultaremos la tabla para que devuelva todas las publicaciones creadas por Nadia.

En el panel Queries (Consultas), pegue la siguiente consulta:


query allPostsByAuthor {
  allPostsByAuthor(author: "Nadia") {
    posts {
      id
      title
    }
    nextToken
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Todas las publicaciones creadas por Nadia deben aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world"
        },
        {
          "id": "11",
          "title": "Did you know...?"
        }
      ],
      "nextToken": null
    }
  }
}

La paginación funciona con Query de igual modo que con Scan. Por ejemplo, vamos a buscar todas las publicaciones de AUTHORNAME y obtener cinco cada vez.

En el panel Queries (Consultas), pegue la siguiente consulta:


query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    count: 5
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Todas las publicaciones creadas por AUTHORNAME deben aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "6",
          "title": "A series of posts, Volume 6"
        },
        {
          "id": "4",
          "title": "A series of posts, Volume 4"
        },
        {
          "id": "2",
          "title": "A series of posts, Volume 2"
        },
        {
          "id": "7",
          "title": "A series of posts, Volume 7"
        },
        {
          "id": "1",
          "title": "A series of posts, Volume 1"
        }
      ],
      "nextToken": "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ=="
    }
  }
}

Actualice el argumento nextToken con el valor devuelto en la consulta anterior, de este modo:


query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    count: 5
    nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ=="
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Las demás publicaciones creadas por AUTHORNAME deben aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "8",
          "title": "A series of posts, Volume 8"
        },
        {
          "id": "5",
          "title": "A series of posts, Volume 5"
        },
        {
          "id": "3",
          "title": "A series of posts, Volume 3"
        },
        {
          "id": "9",
          "title": "A series of posts, Volume 9"
        }
      ],
      "nextToken": null
    }
  }
}

Uso de conjuntos

Hasta ahora, el tipo Post era un objeto clave/valor plano. También puede modelar objetos complejos con el solucionador AWS AppSyncDynamo de bases de datos, como conjuntos, listas y mapas.

Vamos a actualizar el tipo Post para incluir etiquetas. Una publicación puede tener cero o más etiquetas, que se almacenan en DynamoDB como un conjunto de cadenas. También configuraremos algunas mutaciones para añadir y eliminar etiquetas, y una nueva consulta para buscar las publicaciones con una etiqueta concreta.

Elija la pestaña Schema (Esquema).

En el panel Schema (Esquema) modifique el tipo Post para agregar un nuevo campo tags, de este modo:


type Post {
  id: ID!
  author: String
  title: String
  content: String
  url: String
  ups: Int!
  downs: Int!
  version: Int!
  tags: [String!]
}

En el panel Schema (Esquema) modifique el tipo Query para agregar una nueva consulta allPostsByTag, de este modo:


type Query {
  allPostsByTag(tag: String!, count: Int, nextToken: String): PaginatedPosts!
  allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts!
  allPost(count: Int, nextToken: String): PaginatedPosts!
  getPost(id: ID): Post
}

En el panel Schema (Schema), modifique el tipo Mutation para agregar las nuevas mutaciones addTag y removeTag, de este modo:


type Mutation {
  addTag(id: ID!, tag: String!): Post
  removeTag(id: ID!, tag: String!): Post
  deletePost(id: ID!, expectedVersion: Int): Post
  upvotePost(id: ID!): Post
  downvotePost(id: ID!): Post
  updatePost(
    id: ID!,
    author: String,
    title: String,
    content: String,
    url: String,
    expectedVersion: Int!
  ): Post
  addPost(
    author: String!,
    title: String!,
    content: String!,
    url: String!
  ): Post!
}

Seleccione Guardar.
En el panel de tipos de datos de la derecha, busque el campo allPostsByEtiqueta recién creado en el tipo de consulta y, a continuación, elija Adjuntar.
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:


{
    "version" : "2017-02-28",
    "operation" : "Scan",
    "filter": {
      "expression": "contains (tags, :tag)",
        "expressionValues": {
          ":tag": $util.dynamodb.toDynamoDBJson($context.arguments.tag)
        }
    }
    #if( ${context.arguments.count} )
        ,"limit": $util.toJson($context.arguments.count)
    #end
    #if( ${context.arguments.nextToken} )
        ,"nextToken": $util.toJson($context.arguments.nextToken)
    #end
}

En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:


{
    "posts": $utils.toJson($context.result.items)
    #if( ${context.result.nextToken} )
        ,"nextToken": $util.toJson($context.result.nextToken)
    #end
}

Seleccione Guardar.
En el panel de tipos de datos de la derecha, busca el addTagcampo recién creado en el tipo de mutación y, a continuación, selecciona Adjuntar.
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "ADD tags :tags, version :plusOne",
        "expressionValues" : {
            ":tags" : { "SS": [ $util.toJson($context.arguments.tag) ] },
            ":plusOne" : { "N" : 1 }
        }
    }
}

En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```
Seleccione Guardar.
En el panel de tipos de datos de la derecha, busca el removeTagcampo recién creado en el tipo de mutación y, a continuación, selecciona Adjuntar.
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "DELETE tags :tags ADD version :plusOne",
        "expressionValues" : {
            ":tags" : { "SS": [ $util.toJson($context.arguments.tag) ] },
            ":plusOne" : { "N" : 1 }
        }
    }
}

En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```
Seleccione Guardar.

APILlámalos para trabajar con etiquetas

Ahora que ha configurado los resolutores, AWS AppSync sabe cómo traducir las solicitudes entrantes addTag y las allPostsByTag solicitudes a UpdateItem DynamoDB Scan y a las operaciones. removeTag

Para probarlo, vamos a seleccionar una de las publicaciones que ha creado anteriormente. Por ejemplo, tomemos una publicación creada por Nadia.

Seleccione la pestaña Queries (Consultas).

En el panel Queries (Consultas), pegue la siguiente consulta:


query allPostsByAuthor {
  allPostsByAuthor(
    author: "Nadia"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Todas las publicaciones creadas por Nadia deben aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world"
        },
        {
          "id": "11",
          "title": "Did you known...?"
        }
      ],
      "nextToken": null
    }
  }
}

Usemos el que tiene el título "The cutest dog in the world". Anote su id, ya que vamos a utilizarlo más adelante.

Ahora probemos a añadirle la etiqueta dog.

En el panel Queries (Consultas), pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente.
```
mutation addTag {
  addTag(id:10 tag: "dog") {
    id
    title
    tags
  }
}
```
Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

La publicación se actualiza con la nueva etiqueta.


{
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog"
      ]
    }
  }
}

Puede agregar más etiquetas, de este modo:

Actualice la mutación para cambiar el argumento tag a puppy.


mutation addTag {
  addTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

La publicación se actualiza con la nueva etiqueta.


{
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog",
        "puppy"
      ]
    }
  }
}

También puede eliminar etiquetas:

En el panel Queries (Consultas), pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente.
```
mutation removeTag {
  removeTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}
```
Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

La publicación se actualiza y la etiqueta puppy se elimina.


{
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog"
      ]
    }
  }
}

También puede buscar todas las publicaciones que tengan una etiqueta:

En el panel Queries (Consultas), pegue la siguiente consulta:


query allPostsByTag {
  allPostsByTag(tag: "dog") {
    posts {
      id
      title
      tags
    }
    nextToken
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Se devolverán todas las publicaciones que tenga la etiqueta dog, de este modo:


{
  "data": {
    "allPostsByTag": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world",
          "tags": [
            "dog",
            "puppy"
          ]
        }
      ],
      "nextToken": null
    }
  }
}

Uso de listas y mapas

Además de usar conjuntos de DynamoDB, también puede usar las listas y mapas de DynamoDB para modelar datos complejos con un único objeto.

Vamos a añadir la capacidad de agregar comentarios a las publicaciones. Esto se modelará como una lista de objetos de mapa para el objeto Post en DynamoDB.

Nota: en una aplicación real, los comentarios se incluirían en su propia tabla. Para este tutorial, nos limitaremos a añadirlos a la tabla Post.

Elija la pestaña Schema (Esquema).
En el panel Schema (Esquema), agregue un nuevo tipo Comment de este modo:
```
type Comment {
    author: String!
    comment: String!
}
```

En el panel Schema (Esquema) modifique el tipo Post para agregar un nuevo campo comments, de este modo:


type Post {
  id: ID!
  author: String
  title: String
  content: String
  url: String
  ups: Int!
  downs: Int!
  version: Int!
  tags: [String!]
  comments: [Comment!]
}

En el panel Schema (Esquema) modifique el tipo Mutation para agregar una nueva mutación addComment de este modo:


type Mutation {
  addComment(id: ID!, author: String!, comment: String!): Post
  addTag(id: ID!, tag: String!): Post
  removeTag(id: ID!, tag: String!): Post
  deletePost(id: ID!, expectedVersion: Int): Post
  upvotePost(id: ID!): Post
  downvotePost(id: ID!): Post
  updatePost(
    id: ID!,
    author: String,
    title: String,
    content: String,
    url: String,
    expectedVersion: Int!
  ): Post
  addPost(
    author: String!,
    title: String!,
    content: String!,
    url: String!
  ): Post!
}

Seleccione Guardar.
En el panel de tipos de datos de la derecha, busque el addCommentcampo recién creado en el tipo de mutación y, a continuación, seleccione Adjuntar.
En Data source name (Nombre del origen de datos), elija PostDynamoDBTable.

En Configure the request mapping template (Configurar la plantilla de mapeo de solicitud), pegue lo siguiente:


{
  "version" : "2017-02-28",
  "operation" : "UpdateItem",
  "key" : {
    "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
  },
  "update" : {
    "expression" : "SET comments = list_append(if_not_exists(comments, :emptyList), :newComment) ADD version :plusOne",
    "expressionValues" : {
      ":emptyList": { "L" : [] },
      ":newComment" : { "L" : [
        { "M": {
          "author": $util.dynamodb.toDynamoDBJson($context.arguments.author),
          "comment": $util.dynamodb.toDynamoDBJson($context.arguments.comment)
          }
        }
      ] },
      ":plusOne" : $util.dynamodb.toDynamoDBJson(1)
    }
  }
}

Esta expresión de actualización agregará una lista con nuestro nuevo comentario a la lista comments existente. Si la lista no existe todavía, se creará.

En Configure the response mapping template (Configurar la plantilla de mapeo de respuesta), pegue lo siguiente:
```
$utils.toJson($context.result)
```
Seleccione Guardar.

APILlámalos para añadir un comentario

Ahora que ha configurado los resolutores, AWS AppSync sabe cómo convertir las addComment solicitudes entrantes en operaciones de DynamoDBUpdateItem.

Vamos a probarlo añadiendo un comentario a la misma publicación a la que añadimos las etiquetas.

Seleccione la pestaña Queries (Consultas).

En el panel Queries (Consultas), pegue la siguiente consulta:


mutation addComment {
  addComment(
    id:10
    author: "Steve"
    comment: "Such a cute dog."
  ) {
    id
    comments {
      author
      comment
    }
  }
}

Elija Execute query (Ejecutar consulta) (el botón de reproducción naranja).

Todas las publicaciones creadas por Nadia deben aparecer en el panel de resultados a la derecha del panel de consultas. Debería parecerse a lo que sigue:


{
  "data": {
    "addComment": {
      "id": "10",
      "comments": [
        {
          "author": "Steve",
          "comment": "Such a cute dog."
        }
      ]
    }
  }
}

Si ejecuta la solicitud varias veces, se agregarán varios comentarios a la lista.

Conclusión

En este tutorial, ha creado uno API que nos permite manipular objetos Post en DynamoDB mediante GraphQL AWS AppSync . Para obtener más información, consulte la Referencia de plantillas de mapeo de solucionador para Elasticsearch.

Para limpiar, puedes eliminar el AppSync GraphQL API de la consola.

Para eliminar la tabla de DynamoDB y IAM el rol que creó para este tutorial, puede ejecutar lo siguiente para eliminar la pila o visitar AWSAppSyncTutorialForAmazonDynamoDB la consola y eliminar AWS CloudFormation la pila:


aws cloudformation delete-stack \
    --stack-name AWSAppSyncTutorialForAmazonDynamoDB

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

VTLtutoriales de resolución

Uso de resolutores AWS Lambda