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.
# Creación de consultas básicas (VTL)
**nota**
Ahora admitimos de forma básica el tiempo de ejecución APPSYNC\$1JS y su documentación. Considere la opción de utilizar el tiempo de ejecución APPSYNC\$1JS y sus guías [aquí](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html).
Los solucionadores de GraphQL conectan los campos de un esquema de tipo a un origen de datos. Los resolutores son el mecanismo mediante el cual se tramitan las solicitudes. AWS AppSync pueden crear y conectar automáticamente resolutores a partir de un esquema o crear un esquema y conectar resolutores desde una tabla existente sin necesidad de escribir ningún código.
Resolvers que se AWS AppSync utilizan JavaScript para convertir una expresión de GraphQL en un formato que pueda utilizar la fuente de datos. Como alternativa, las plantillas de asignación se pueden escribir en [Apache Velocity Template Language (VTL)](https://velocity.apache.org/engine/2.0/vtl-reference.html) para convertir una expresión de GraphQL en un formato que el origen de datos pueda utilizar.
En esta sección se mostrará cómo configurar los solucionadores mediante VTL. [En la guía de programación de plantillas de mapeo de Resolver encontrará una guía de programación tipo tutorial introductorio para escribir [resolutores, y en la referencia contextual de la plantilla de mapeo](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide) de Resolver encontrará utilidades auxiliares para su uso durante la programación.](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference) AWS AppSync también incluye flujos de prueba y depuración integrados que puedes usar cuando editas o creas desde cero. Para obtener más información, consulte la sección sobre la [prueba y depuración de solucionadores](test-debug-resolvers.md#aws-appsync-test-debug-resolvers).
Recomendamos seguir esta guía antes de intentar utilizar alguno de los tutoriales mencionados anteriormente.
En esta sección, veremos cómo crear un solucionador, añadir un solucionador para mutaciones y usar configuraciones avanzadas.
## Cree su primer solucionador
Siguiendo los ejemplos de las secciones anteriores, el primer paso es crear un solucionador para su tipo de `Query`.
------
#### [ Console ]
1. [Inicia sesión en la consola Consola de administración de AWS y ábrelaAppSync .](https://console.aws.amazon.com/appsync/)
1. En el **APIs panel de control**, elige tu API de GraphQL.
1. En la **barra lateral**, seleccione **Esquema**.
1. En la parte derecha de la página, hay una ventana llamada **Solucionadores**. Este cuadro contiene una lista de los tipos y campos definidos en la ventana **Esquema** del lado izquierdo de la página. Puede asociar solucionadores a los campos. Por ejemplo, en el tipo de **Consulta**, seleccione **Asociar** junto al campo `getTodos`.
1. En la página **Crear un solucionador**, elija el origen de datos que creó en la guía [Asociar un origen de datos](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html). En la ventana **Configurar plantillas de asignación**, puede elegir las plantillas de asignación genéricas de solicitud y respuesta utilizando la lista desplegable de la derecha o escribir las suyas propias.
**nota**
El emparejamiento de una plantilla de asignación de solicitudes con una plantilla de asignación de respuestas se denomina solucionador unitario. Los solucionadores unitarios suelen estar diseñados para realizar operaciones rutinarias; recomendamos usarlos solo para operaciones singulares con un número reducido de orígenes de datos. Para operaciones más complejas, recomendamos utilizar solucionadores de canalización, que pueden ejecutar varias operaciones con diversos orígenes de datos de forma secuencial.
Para obtener más información acerca de la diferencia entre las plantillas de asignación de solicitudes y respuestas, consulte [Solucionadores unitarios](https://docs.aws.amazon.com//appsync/latest/devguide/resolver-mapping-template-reference-overview.html#unit-resolvers).
Para obtener más información sobre el uso de solucionadores de canalización, consulte [Solucionadores de canalización](pipeline-resolvers.md#aws-appsync-pipeline-resolvers).
1. Para los casos de uso más comunes, la AWS AppSync consola tiene plantillas integradas que puedes usar para obtener elementos de fuentes de datos (por ejemplo, todas las consultas de elementos, búsquedas individuales, etc.). Por ejemplo en la versión sencilla del esquema que se da en la sección [Diseño del esquema](designing-your-schema.md#aws-appsync-designing-your-schema) en la que `getTodos` no tenía paginación, la plantilla de asignación de solicitudes para enumerar elementos es la siguiente:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Siempre se necesita una plantilla de asignación de respuestas para complementar la solicitud. La consola ofrece un valor predeterminado con el siguiente valor de acceso directo para las listas:
```
$util.toJson($ctx.result.items)
```
En este ejemplo, el objeto `context` (con el alias `$ctx`) para las listas de elementos tiene la forma `$context.result.items`. Si su operación de GraphQL devuelve un solo elemento, sería `$context.result`. AWS AppSync proporciona funciones auxiliares para operaciones comunes como la función `$util.toJson` enumerada anteriormente, para dar formato a las respuestas correctamente. Para ver una lista completa de funciones, consulte [Referencia de utilidad de la plantilla de asignación de solucionadores](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).
1. Seleccione **Guardar solucionador**.
------
#### [ API ]
1. Cree un objeto de resolución llamando a la API de [https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html).
1. Puede modificar los campos del solucionador llamando a la API de [https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html).
------
#### [ CLI ]
1. Cree un solucionador ejecutando el comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html).
Deberá escribir 6 parámetros para este comando concreto:
1. El `api-id` de su API.
1. El `type-name` del tipo que quiere modificar en su esquema. En el ejemplo de la consola, esto era `Query`.
1. El `field-name` del campo que quiere modificar en su tipo. En el ejemplo de la consola, esto era `getTodos`.
1. El `data-source-name` del origen de datos que creó en la guía [Asociar un origen de datos](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. La `request-mapping-template`, que es el cuerpo de la solicitud. En el ejemplo de la consola, esto era:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. La `response-mapping-template`, que es el cuerpo de la respuesta. En el ejemplo de la consola, esto era:
```
$util.toJson($ctx.result.items)
```
Un comando de ejemplo puede tener este aspecto:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Query --field-name getTodos --data-source-name TodoTable --request-mapping-template "{ "version" : "2017-02-28", "operation" : "Scan", }" --response-mapping-template ""$"util.toJson("$"ctx.result.items)"
```
Aparecerá un resultado en la CLI. A continuación se muestra un ejemplo:
```
{
"resolver": {
"kind": "UNIT",
"dataSourceName": "TodoTable",
"requestMappingTemplate": "{ version : 2017-02-28, operation : Scan, }",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Query/resolvers/getTodos",
"typeName": "Query",
"fieldName": "getTodos",
"responseMappingTemplate": "$util.toJson($ctx.result.items)"
}
}
```
1. Para modificar las plantillas de and/or mapeo de campos de un solucionador, ejecute el [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html)comando.
Con la excepción del parámetro `api-id`, los parámetros utilizados en el comando `create-resolver` se sobrescribirán con los nuevos valores del comando `update-resolver`.
------
## Adición de un solucionador para mutaciones
El siguiente paso es crear un solucionador para su tipo de `Mutation`.
------
#### [ Console ]
1. Inicie sesión en la [AppSync consola Consola de administración de AWS y ábrala](https://console.aws.amazon.com/appsync/).
1. En el **APIs panel de control**, elige tu API de GraphQL.
1. En la **barra lateral**, seleccione **Esquema**.
1. En el tipo de **Mutación**, seleccione **Asociar** junto al campo `addTodo`.
1. En la página **Crear un solucionador**, elija el origen de datos que creó en la guía [Asociar un origen de datos](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. En la ventana **Configurar plantillas de asignación**, modifique la plantilla de solicitud, ya que se trata de una mutación en la que se añade un elemento nuevo a DynamoDB. Use la siguiente plantilla de asignación de solicitud.
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
1. AWS AppSync convierte automáticamente los argumentos definidos en el `addTodo` campo del esquema de GraphQL en operaciones de DynamoDB. En el ejemplo anterior se almacenan registros en DynamoDB mediante una clave de `id`, que se transfiere desde el argumento de mutación como `$ctx.args.id`. Todos los demás campos que transfiera se mapearán automáticamente en atributos de DynamoDB con `$util.dynamodb.toMapValuesJson($ctx.args)`.
Para este solucionador, use la siguiente plantilla de mapeo de respuesta:
```
$util.toJson($ctx.result)
```
AWS AppSync también admite flujos de trabajo de prueba y depuración para la edición de resoluciones. Puede usar un objeto `context` simulado para ver el valor transformado de la plantilla antes de la invocación. De forma opcional, puede ver la ejecución de la solicitud completa en un origen de datos de forma interactiva cuando ejecute una consulta. Para obtener más información, consulte las secciones sobre [prueba y depuración de solucionadores](test-debug-resolvers.md#aws-appsync-test-debug-resolvers) y sobre [monitorización y registro](monitoring.md#aws-appsync-monitoring).
1. Seleccione **Guardar solucionador**.
------
#### [ API ]
También puede hacerlo APIs utilizando los comandos de la sección [Cree su primera resolución](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) y los detalles de los parámetros de esta sección.
------
#### [ CLI ]
También puede hacer esto en la CLI utilizando los comandos de la sección [Cree su primer solucionador](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) y los detalles de los parámetros de esta sección.
------
En este momento, si no usa los solucionadores avanzados, puede empezar a utilizar su API de GraphQL tal como se indica en [Uso de la API](using-your-api.md#aws-appsync-using-your-api).
## Solucionadores avanzados
Si está siguiendo la sección avanzada y crea un esquema de ejemplo en [Diseño del esquema](designing-your-schema.md#aws-appsync-designing-your-schema) para realizar un análisis paginado, utilice la siguiente plantilla de solicitud para el campo `getTodos`:
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"limit": $util.defaultIfNull(${ctx.args.limit}, 20),
"nextToken": $util.toJson($util.defaultIfNullOrBlank($ctx.args.nextToken, null))
}
```
En este caso de uso de paginación el mapeo de la respuesta es algo más que un acceso directo, ya que debe contener tanto el *cursor* (de modo que el cliente sepa en qué página comenzar a continuación) como el conjunto de resultados. La plantilla de mapeo es la siguiente:
```
{
"todos": $util.toJson($context.result.items),
"nextToken": $util.toJson($context.result.nextToken)
}
```
Los campos de la plantilla de mapeo de respuesta anterior tienen que coincidir con los campos definidos en su tipo `TodoConnection`.
En el caso de las relaciones en las que tiene una tabla `Comments` y usted está solucionando el campo de comentarios del tipo `Todo` (que devuelve un tipo de `[Comment]`), puede utilizar una plantilla de asignación que ejecute una consulta en la segunda tabla. Para ello, ya debe haber creado un origen de datos para la tabla `Comments` tal como se indica en [Asociar un origen de datos](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch).
**nota**
Usamos una operación de consulta en otra tabla solo con fines ilustrativos. También podría usar otra operación realizada en DynamoDB en su lugar. Además, puede extraer los datos de otra fuente de datos, como AWS Lambda Amazon OpenSearch Service, ya que la relación está controlada por su esquema de GraphQL.
------
#### [ Console ]
1. Inicia sesión en la [AppSync consola Consola de administración de AWS](https://console.aws.amazon.com/appsync/) y ábrela.
1. En el **APIs panel de control**, elige tu API de GraphQL.
1. En la **barra lateral**, seleccione **Esquema**.
1. En el tipo **Todo**, seleccione **Asociar** junto al campo `comments`.
1. En la página **Crear solucionador**, elija el origen de datos de la tabla **Comentarios**. El nombre predeterminado de la tabla **Comentarios** en las guías de inicio rápido es `AppSyncCommentTable`, pero puede variar en función del nombre que le haya dado.
1. Añada el siguiente fragmento de código a su plantilla de asignación de solicitud:
```
{
"version": "2017-02-28",
"operation": "Query",
"index": "todoid-index",
"query": {
"expression": "todoid = :todoid",
"expressionValues": {
":todoid": {
"S": $util.toJson($context.source.id)
}
}
}
}
```
1. `context.source` hace referencia al objeto principal del campo actual que se está resolviendo. En este ejemplo, `source.id` hace referencia al objeto `Todo` individual, que se usa a continuación para la expresión de consulta.
Puede utilizar la plantilla de mapeo de respuesta de acceso directo de la siguiente manera:
```
$util.toJson($ctx.result.items)
```
1. Seleccione **Guardar solucionador**.
1. Por último, en la página **Esquema**, asocie un solucionador al campo `addComment` y especifique el origen de datos para la tabla `Comments`. La plantilla de mapeo de solicitud en este caso es un elemento `PutItem` sencillo con el elemento `todoid` específico en el que se realiza el comentario como argumento, pero usa la utilidad `$utils.autoId()` para crear una clave de ordenación única para el comentario de la siguiente manera:
```
{
"version": "2017-02-28",
"operation": "PutItem",
"key": {
"todoid": { "S": $util.toJson($context.arguments.todoid) },
"commentid": { "S": "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Utilice una plantilla de respuesta de acceso directo de la siguiente manera:
```
$util.toJson($ctx.result)
```
------
#### [ API ]
También puedes hacerlo APIs utilizando los comandos de la sección [Crea tu primera resolución](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) y los detalles de los parámetros de esta sección.
------
#### [ CLI ]
También puede hacer esto en la CLI utilizando los comandos de la sección [Cree su primer solucionador](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) y los detalles de los parámetros de esta sección.
------
# Desactivación de las plantillas de mapeo de VTL con solucionadores de Lambda directos (VTL)
**nota**
Ahora admitimos de forma básica el tiempo de ejecución APPSYNC\$1JS y su documentación. Considere la opción de utilizar el tiempo de ejecución APPSYNC\$1JS y sus guías [aquí](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html).
Con los resolutores Lambda directos, puede evitar el uso de plantillas de mapeo de VTL al utilizar fuentes de datos. AWS Lambda AWS AppSync puede proporcionar una carga útil predeterminada a la función de Lambda, así como una traducción predeterminada de la respuesta de una función de Lambda a un tipo de GraphQL. Puedes elegir entre proporcionar una plantilla de solicitud, una plantilla de respuesta o ninguna de las dos, y la AWS AppSync gestionarás en consecuencia.
Para obtener más información sobre la carga útil de solicitud predeterminada y la traducción de respuestas que AWS AppSync proporciona, consulte la referencia de resolución de [Direct Lambda](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers). Para obtener más información sobre la configuración de una fuente de AWS Lambda datos y la configuración de una política de confianza de IAM, consulte [Adjuntar](attaching-a-data-source.md) una fuente de datos.
## Configurar solucionadores de Lambda directos
En las secciones siguientes, se muestra cómo asociar orígenes de datos de Lambda y cómo añadir solucionadores de Lambda a los campos.
### Añadir un origen de datos de Lambda
Para poder activar los solucionadores de Lambda directos, debe añadir un origen de datos de Lambda.
------
#### [ Console ]
1. [Inicie sesión en la consola Consola de administración de AWS y ábrala. AppSync](https://console.aws.amazon.com/appsync/)
1. En el **APIs panel de control**, elige tu API de GraphQL.
1. En la **barra lateral**, seleccione **Origen de datos**.
1. Elija **Crear origen de datos**.
1. En **Nombre de origen de datos**, introduzca un nombre para el origen de datos (por ejemplo, **myFunction**).
1. En **Tipo de origen de datos**, elija **AWS Lambda Ninguno**.
1. En **Región**, elija la región apropiada.
1. En **ARN de la función**, elija la función de Lambda en la lista desplegable. Puede buscar el nombre de la función o introducir manualmente el ARN de la función que desee utilizar.
1. Cree un nuevo rol de IAM (recomendado) o elija un rol existente que tenga el permiso de IAM `lambda:invokeFunction`. Los roles existentes necesitan una política de confianza, tal y como se explica en la sección [Asociar un origen de datos](attaching-a-data-source.md).
El siguiente es un ejemplo de política de IAM que tiene los permisos necesarios para llevar a cabo operaciones en el recurso:
------
#### [ JSON ]
****
```
{
"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:*"
]
}
]
}
```
------
1. Pulse el botón **Crear**.
------
#### [ CLI ]
1. Cree un origen de datos ejecutando el comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html).
Deberá escribir 4 parámetros para este comando concreto:
1. El `api-id` de su API.
1. El `name` de origen de datos. En el ejemplo de la consola, este es el **nombre del origen de datos**.
1. El `type` de origen de datos. En el ejemplo de la consola, se trata de una **función AWS Lambda **.
1. El `lambda-config`, que es el **ARN de la función** el ejemplo de la consola.
**nota**
Hay otros parámetros, como `Region`, que deben configurarse pero que normalmente se utilizarán de forma predeterminada en los valores de configuración de la CLI.
Un comando de ejemplo puede tener este aspecto:
```
aws appsync create-data-source --api-id abcdefghijklmnopqrstuvwxyz --name myFunction --type AWS_LAMBDA --lambda-config lambdaFunctionArn=arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example
```
Aparecerá un resultado en la CLI. A continuación se muestra un ejemplo:
```
{
"dataSource": {
"dataSourceArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/datasources/myFunction",
"type": "AWS_LAMBDA",
"name": "myFunction",
"lambdaConfig": {
"lambdaFunctionArn": "arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example"
}
}
}
```
1. Para modificar los atributos de un origen de datos, ejecute el comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html).
Con la excepción del parámetro `api-id`, los parámetros utilizados en el comando `create-data-source` se sobrescribirán con los nuevos valores del comando `update-data-source`.
------
### Activar los solucionadores de Lambda directos
Tras crear una fuente de datos Lambda y configurar la función de IAM adecuada para poder AWS AppSync invocar la función, puede vincularla a una función de resolución o de canalización.
------
#### [ Console ]
1. [Inicie sesión en la consola Consola de administración de AWS y ábrala. AppSync](https://console.aws.amazon.com/appsync/)
1. En el **APIs panel de control**, elige tu API de GraphQL.
1. En la **barra lateral**, seleccione **Esquema**.
1. En la ventana **Solucionadores**, elija un campo u operación y, a continuación, seleccione el botón **Asociar**.
1. En la página **Crear nuevo solucionador**, elija la función de Lambda en la lista desplegable.
1. Para aprovechar los solucionadores de Lambda directos, confirme que las plantillas de asignación de solicitud y respuesta estén deshabilitadas en la sección **Configurar plantillas de asignación**.
1. Pulse el botón **Guardar solucionador**.
------
#### [ CLI ]
+ Cree un solucionador ejecutando el comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html).
Deberá escribir 6 parámetros para este comando concreto:
1. El `api-id` de su API.
1. El `type-name` del tipo de su esquema.
1. El `field-name` del campo de su esquema.
1. El `data-source-name` o el nombre de su función de Lambda.
1. La `request-mapping-template`, que es el cuerpo de la solicitud. En el ejemplo de la consola, esto estaba deshabilitado:
```
" "
```
1. La `response-mapping-template`, que es el cuerpo de la respuesta. En el ejemplo de la consola, esto también estaba deshabilitado:
```
" "
```
Un comando de ejemplo puede tener este aspecto:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Subscription --field-name onCreateTodo --data-source-name LambdaTest --request-mapping-template " " --response-mapping-template " "
```
Aparecerá un resultado en la CLI. A continuación se muestra un ejemplo:
```
{
"resolver": {
"resolverArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/types/Subscription/resolvers/onCreateTodo",
"typeName": "Subscription",
"kind": "UNIT",
"fieldName": "onCreateTodo",
"dataSourceName": "LambdaTest"
}
}
```
------
Al deshabilitar las plantillas de asignación, en AWS AppSync se producen varios comportamientos adicionales:
+ Al deshabilitar una plantilla de mapeo, indica AWS AppSync que acepta las traducciones de datos predeterminadas especificadas en la referencia de resolución de Direct [Lambda](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers).
+ Al deshabilitar la plantilla de asignación de solicitudes, el origen de datos de Lambda recibirá una carga compuesta por todo el objeto [Context](resolver-context-reference.md).
+ Al deshabilitar la plantilla de asignación de respuestas, el resultado de la invocación de Lambda se traducirá en función de la versión de la plantilla de asignación de solicitudes o de si la plantilla de asignación de solicitudes también está deshabilitada.
# Prueba y depuración de resolutores en AWS AppSync (VTL)
**nota**
Ahora admitimos de forma básica el tiempo de ejecución APPSYNC\$1JS y su documentación. Considere la opción de utilizar el tiempo de ejecución APPSYNC\$1JS y sus guías [aquí](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html).
AWS AppSync ejecuta resolutores en un campo GraphQL contra una fuente de datos. Como se describe en [Resolver mapping template overview](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview), los solucionadores se comunican con los orígenes de datos mediante un lenguaje de plantillas. Esto permite personalizar el comportamiento y aplicar lógica y condiciones antes y después de comunicarse con el origen de datos. Encontrará una guía de programación introductoria similar a un tutorial para escribir solucionadores en [Resolver mapping template programming guide](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide).
Para ayudar a los desarrolladores a escribir, probar y depurar estos resolutores, la AWS AppSync consola también proporciona herramientas para crear una solicitud y una respuesta de GraphQL con datos simulados para cada solucionador de campo individual. Además, puedes realizar consultas, mutaciones y suscripciones en la AWS AppSync consola y ver un registro detallado de Amazon CloudWatch de toda la solicitud. Esto incluye los resultados del origen de datos.
## Prueba con datos simulados
Cuando se invoca a un solucionador de GraphQL, este contiene un objeto `context` que incluye información sobre la solicitud. Por ejemplo, contiene los argumentos de un cliente, información de identidad y datos del campo principal de GraphQL. También contiene los resultados del origen de datos, que puede usar en la plantilla de respuesta. Si desea más información acerca de esta estructura y las utilidades auxiliares disponibles para programar, consulte la [Referencia del contexto de las plantillas de mapeo de solucionador](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).
Al escribir o editar un solucionador, puede pasar un objeto *simulado* o *de contexto de prueba* al editor de la consola. Esto le permite ver cómo se evalúan la plantillas de solicitud y de respuesta sin que se utilice en realidad ningún origen de datos. Por ejemplo, puede transferir un argumento `firstname: Shaggy` de prueba y ver cómo se evalúa cuando utiliza `$ctx.args.firstname` en el código de la plantilla. También puede probar la evaluación de cualquier utilidad auxiliar, como `$util.autoId()` o `util.time.nowISO8601()`.
### Prueba de solucionadores
En este ejemplo, se utilizará la AWS AppSync consola para probar los resolutores.
1. Inicie sesión en la [AppSyncconsola Consola de administración de AWS](https://console.aws.amazon.com/appsync/) y ábrala.
1. En el **APIs panel**, elige tu API de GraphQL.
1. En la **barra lateral**, seleccione **Esquema**.
1. Si aún no lo ha hecho, en el tipo y junto al campo, seleccione **Asociar** para añadir su solucionador.
Para obtener más información acerca de cómo crear un solucionador completo, consulte [Configuring resolvers](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html).
De lo contrario, seleccione el solucionador que ya esté en el campo.
1. En la parte superior de la página **Editar el solucionador**, seleccione **Seleccionar contexto de prueba** y, a continuación, **Crear nuevo contexto**.
1. Seleccione un objeto de contexto de ejemplo o rellene el JSON manualmente en la ventana **Contexto de ejecución** que aparece a continuación.
1. Introduzca un **Nombre de contexto de texto**.
1. Seleccione el botón **Guardar**.
1. En la parte superior de la página **Editar solucionador**, seleccione **Ejecutar prueba**.
Veamos un ejemplo más práctico. Imagine que tiene una aplicación que almacena un tipo de GraphQL llamado `Dog`, que genera automáticamente un identificador para los objetos y los almacena en Amazon DynamoDB. También desea escribir algunos valores tomándolos de los argumentos de una mutación de GraphQL y permitir que solo determinados usuarios vean la respuesta. El esquema podría tener el siguiente aspecto:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Al añadir un solucionador para la mutación `addDog`, puede rellenar un objeto de contexto como el que aparece en el ejemplo a continuación. Se incluyen argumentos del cliente como `name` y `age`, así como un `username` rellenado en el objeto `identity`:
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
Puede probarlo utilizando las siguientes plantillas de mapeo de solicitud y de respuesta:
**Plantilla de solicitud**
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
**Plantilla de respuesta**
```
#if ($context.identity.username == "Nadia")
$util.toJson($ctx.result)
#else
$util.unauthorized()
#end
```
La plantilla evaluada tiene los datos del objeto de contexto de prueba y el valor generado por `$util.autoId()`. Además, si cambia el `username` por un valor distinto de `Nadia`, no se devolverán resultados, porque la comprobación de autorización daría error. Para obtener más información acerca del control de acceso preciso, consulte [Casos de uso de autorizaciones](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).
### Probando plantillas de mapeo con AWS AppSync APIs
Puede usar el comando de API `EvaluateMappingTemplate` para probar las plantillas de mapeo de forma remota con datos simulados. Para empezar a usar el comando, asegúrese de haber añadido el permiso `appsync:evaluateMappingTemplate` a su política. Por ejemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateMappingTemplate",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Puede aprovechar el comando mediante la tecla [AWS CLI](https://aws.amazon.com/cli/)o [AWS SDKs](https://aws.amazon.com/tools/). Por ejemplo, tome el `Dog` esquema y sus plantillas de request/response mapeo de la sección anterior. Con la CLI de la estación local, guarde la plantilla de solicitudes en un archivo denominado `request.vtl` y, a continuación, guarde el objeto `context` en un archivo denominado `context.json`. Ejecute el siguiente comando desde el intérprete de comandos:
```
aws appsync evaluate-mapping-template --template file://request.vtl --context file://context.json
```
El comando devuelve la siguiente respuesta:
```
{
"evaluationResult": "{\n \"version\" : \"2017-02-28\",\n \"operation\" : \"PutItem\",\n \"key\" : {\n \"id\" : { \"S\" : \"afcb4c85-49f8-40de-8f2b-248949176456\" }\n },\n \"attributeValues\" : {\"firstname\":{\"S\":\"Shaggy\"},\"age\":{\"N\":4}}\n}\n"
}
```
`evaluationResult`Contiene los resultados de la prueba de la plantilla proporcionada con el `context` proporcionado. También puede probar sus plantillas con AWS SDKs. Este es un ejemplo del uso del AWS SDK para la JavaScript versión 2:
```
const AWS = require('aws-sdk')
const client = new AWS.AppSync({ region: 'us-east-2' })
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
client
.evaluateMappingTemplate({ template, context })
.promise()
.then((data) => console.log(data))
```
Cuando se utiliza el SDK, puede incorporar fácilmente pruebas de su conjunto de pruebas favorito para validar el comportamiento de la plantilla. Recomendamos crear pruebas con el [marco de pruebas Jest](https://jestjs.io/), pero cualquier conjunto de pruebas funciona. En el siguiente fragmento de código se muestra una ejecución de validación hipotética. Tenga en cuenta que esperamos que la respuesta de la evaluación sea un JSON válido, por lo que utilizamos `JSON.parse` para recuperar el JSON de la respuesta de cadena:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
test('request correctly calls DynamoDB', async () => {
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateMappingTemplate({ template, context }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Esto produce el siguiente resultado:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 1.511 s, estimated 2 s
```
## Depuración de una consulta en tiempo real
No hay nada que sustituya a una end-to-end prueba y un registro para depurar una aplicación de producción. AWS AppSync te permite registrar los errores y los detalles completos de las solicitudes a través de Amazon CloudWatch. Además, puedes usar la AWS AppSync consola para probar las consultas, mutaciones y suscripciones de GraphQL y transmitir en directo los datos de registro de cada solicitud de vuelta al editor de consultas para depurarlos en tiempo real. Para las suscripciones, los registros muestran la información del tiempo de conexión.
Para ello, debes tener habilitados los CloudWatch registros de Amazon con antelación, tal y como se describe en [Supervisión y registro](monitoring.md#aws-appsync-monitoring). A continuación, en la AWS AppSync consola, selecciona la pestaña **Consultas** y, a continuación, introduce una consulta GraphQL válida. En la sección inferior derecha, haga clic y arrastre la ventana **Registros** para abrir la vista de registros. Utilice el icono de flecha de reproducción de la parte superior de la página para ejecutar la consulta de GraphQL. Al cabo de unos momentos, los registros completos de la solicitud y la respuesta de la operación se enviarán a esta sección y podrá verlos en la consola.
# Configuración y uso de solucionadores de canalización en AWS AppSync (VTL)
**nota**
Ahora admitimos de forma básica el tiempo de ejecución APPSYNC\$1JS y su documentación. Considere la opción de utilizar el tiempo de ejecución APPSYNC\$1JS y sus guías [aquí](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html).
AWS AppSync ejecuta resolutores en un campo GraphQL. En algunos casos, las aplicaciones requieren la ejecución de varias operaciones para resolver un único campo de GraphQL. Con los solucionadores de canalización, los desarrolladores ahora pueden componer operaciones llamadas Funciones y ejecutarlas de forma secuencial. Los solucionadores de canalización son útiles para las aplicaciones que, por ejemplo, requieren realizar una comprobación de autorización antes de recuperar datos para un campo.
Un solucionador de canalización se compone de una plantilla de mapeo **Antes**, una plantilla de mapeo **Después** y una lista de funciones. Cada función tiene una plantilla de mapeo de **solicitudes** y **respuestas** que ejecuta con un origen de datos. Puesto que un solucionador de canalización delega la ejecución a una lista de funciones, no está vinculado a ningún origen de datos. Las funciones y los solucionadores de unidad son primitivos que ejecutan operaciones frente a los orígenes de datos. Para obtener más información, consulte [Información general sobre las plantillas de mapeo de solucionador](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).
## Paso 1: creación de un solucionador de canalización
**En la AWS AppSync consola, ve a la página del esquema.**
Guarde el siguiente esquema:
```
schema {
query: Query
mutation: Mutation
}
type Mutation {
signUp(input: Signup): User
}
type Query {
getUser(id: ID!): User
}
input Signup {
username: String!
email: String!
}
type User {
id: ID!
username: String
email: AWSEmail
}
```
Vamos a conectar un solucionador de canalización al campo **signUp** en el tipo **Mutation (Mutación)**. En el tipo **Mutación** en el lado derecho, elija **Asociar** junto al campo de mutación `signUp`. En la página de creación de solucionadores, haga clic en **Acciones** y, a continuación, en **Actualizar el tiempo de ejecución**. Elija `Pipeline Resolver`, luego `VTL` y, a continuación, **Actualizar**. Ahora, la página ahora debería mostrar tres secciones: un área de texto **Plantilla de mapeo Antes**, una sección **Funciones** y un área de texto **Plantilla de mapeo Después**.
Nuestro solucionador de canalización inicia sesión a un usuario. Para ello, primero valida la entrada de dirección de correo electrónico y, a continuación, guarda al usuario en el sistema. Vamos a encapsular la validación de correo electrónico dentro de una función **validateEmail** y el guardado del usuario dentro de una función **saveUser**. La función **validateEmail** se ejecuta en primer lugar y, si el correo electrónico es válido, se ejecuta la función **saveUser**.
El flujo de ejecución será como se indica a continuación:
1. Plantilla de mapeo de solicitud de solucionador Mutation.signUp
1. Función validateEmail
1. Función saveUser
1. Plantilla de mapeo de respuesta de solucionador Mutation.signUp
Dado que probablemente reutilizaremos la función **validateEmail** en otros solucionadores de nuestra API, queremos para evitar el acceso a `$ctx.args`, ya que estos cambiarán de un campo GraphQL a otro. En su lugar, podemos utilizar `$ctx.stash` para almacenar el atributo de correo electrónico desde el argumento de campo de entrada `signUp(input: Signup)`.
Plantilla de mapeo **ANTES**:
```
## store email input field into a generic email key
$util.qr($ctx.stash.put("email", $ctx.args.input.email))
{}
```
La consola ofrece un acceso directo predeterminado de plantilla de mapeo **DESPUÉS** que vamos a utilizar:
```
$util.toJson($ctx.result)
```
Seleccione **Crear** o **Guardar** para actualizar el solucionador.
## Paso 2: creación de una función
En la página del solucionador de canalización, en la sección **Funciones**, haga clic en **Agregar función** y luego en **Crear la función nueva**. También es posible crear funciones sin pasar por la página de resolución; para ello, en la AWS AppSync consola, vaya a la página de **funciones**. Elija el botón **Crear una función**. Vamos a crear una función que comprueba si un mensaje de correo electrónico es válido y proviene de un dominio específico. Si el correo electrónico no es válido, la función genera un error. De lo contrario, reenvía cualquier entrada.
En la nueva página de funciones, seleccione **Acciones** y, a continuación, **Actualizar tiempo de ejecución**. Elija `VTL` y, a continuación, **Actualizar**. Asegúrese de haber creado un origen de datos del tipo **NINGUNO**. Elija este origen de datos en la lista de **Nombre del origen de datos**. Para el **nombre de función**, introduzca `validateEmail`. En el área de **código de la función**, sobrescriba todo con este fragmento:
```
#set($valid = $util.matches("^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com", $ctx.stash.email))
#if (!$valid)
$util.error("$ctx.stash.email is not a valid email.")
#end
{
"payload": { "email": $util.toJson(${ctx.stash.email}) }
}
```
Péguelo en la plantilla de mapeo de respuestas:
```
$util.toJson($ctx.result)
```
Revise sus modificaciones y, a continuación, elija **Crear**. Acabamos de crear nuestra función **validateEmail**. Repita estos pasos para crear la función **SaveUser** con las siguientes plantillas de mapeo de solicitudes y respuestas (para simplificar, utilizamos un origen de datos **NINGUNO** y simulamos que el usuario se ha guardado en el sistema después de ejecutar la función):
Plantilla de mapeo de solicitudes:
```
## $ctx.prev.result contains the signup input values. We could have also
## used $ctx.args.input.
{
"payload": $util.toJson($ctx.prev.result)
}
```
Plantilla de mapeo de respuestas:
```
## an id is required so let's add a unique random identifier to the output
$util.qr($ctx.result.put("id", $util.autoId()))
$util.toJson($ctx.result)
```
Acabamos de crear la función **saveUser**.
## Paso 3: adición de una función a un solucionador de canalización
Nuestras funciones deberían haberse agregado automáticamente al solucionador de canalización que acabamos de crear. Si este no es el caso, o si ha creado las funciones a través de la página **Funciones**, puede volver a hacer clic en **Agregar función** en la página del solucionador para asociarlas. Agregue las funciones **validateEmail** y **saveUser** al solucionador. La función **validateEmail** se debe colocar antes de la función **saveUser**. A medida que agrega más funciones, puede utilizar las opciones **mover hacia arriba** y **mover hacia abajo** para reorganizar el orden de ejecución de las funciones. Revise sus cambios y, a continuación, elija **Guardar**.
## Paso 4: Ejecución de una consulta
En la AWS AppSync consola, vaya a la página de **consultas**. En el explorador, asegúrese de utilizar la mutación. Si no es así, seleccione `Mutation` en la lista desplegable y, a continuación, elija `+`. Escriba la siguiente consulta:
```
mutation {
signUp(input: {
email: "nadia@myvaliddomain.com"
username: "nadia"
}) {
id
email
}
}
```
Debería devolver algo parecido a esto:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"email": "nadia@myvaliddomain.com"
}
}
}
```
Hemos registrado correctamente nuestro usuario y validado el correo electrónico de entrada utilizando un solucionador de canalización. Para seguir un tutorial más completo centrado en los solucionadores de canalización, puede ir al [tutorial de solucionadores de canalización](tutorial-pipeline-resolvers.md#aws-appsync-tutorial-pipeline-resolvers)