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. # 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)