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 (JavaScript)
Los solucionadores de GraphQL conectan los campos de un esquema de tipo a un origen de datos. Los solucionadores son el mecanismo mediante el cual se atienden las solicitudes.
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 describe cómo configurar los resolutores mediante. JavaScript La sección [Tutoriales de resolución (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) proporciona tutoriales detallados sobre cómo implementar resolutores utilizando. JavaScript La sección de [referencia del solucionador (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) proporciona una explicación de las operaciones de utilidad que se pueden utilizar con los JavaScript resolutores.
Recomendamos seguir esta guía antes de intentar utilizar alguno de los tutoriales mencionados anteriormente.
En esta sección se mostrará cómo crear y configurar solucionadores para consultas y mutaciones.
**nota**
En esta guía se supone que ha creado su esquema y que tiene al menos una consulta o mutación. Si busca suscripciones (datos en tiempo real), consulte [esta](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html) guía.
En esta sección, proporcionaremos algunos pasos generales para configurar solucionadores junto con un ejemplo que usa el esquema siguiente:
```
// schema.graphql file
input CreatePostInput {
title: String
date: AWSDateTime
}
type Post {
id: ID!
title: String
date: AWSDateTime
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
## Creación de solucionadores de consultas básicos
En esta sección se mostrará cómo crear un solucionador de consultas básico.
------
#### [ Console ]
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 de control**, elige tu API de GraphQL.
1. En la **barra lateral**, seleccione **Esquema**.
1. Introduzca los detalles del esquema y el origen de datos. Consulte las secciones [Diseño del esquema](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) y [Asociar un origen de datos](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) para obtener más información.
1. Junto al editor **Esquemas**, hay una ventana llamada **Solucionadores**. Este cuadro contiene una lista de los tipos y campos definidos en la ventana **Esquema**. Puede asociar solucionadores a los campos. Lo más probable es que asocie solucionadores a sus operaciones de campo. En esta sección se analizarán las configuraciones de consultas sencillas. En el tipo **Consulta**, seleccione **Asociar** junto al campo de la consulta.
1. En la página **Asociar solucionador**, en **Tipo de solucionador**, puede elegir entre solucionadores de canalización o unitarios. Para obtener más información sobre estos tipos, consulte [Solucionadores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html). En esta guía se utilizará `pipeline resolvers`.
**sugerencia**
Al crear solucionadores de canalización, sus orígenes de datos se asociarán a las funciones de canalización. Las funciones se crean después de crear el propio solucionador de canalizaciones, por lo que no existe la opción de configurarlo en esta página. Si utiliza un solucionador unitario, el origen de datos se vincula directamente al solucionador, por lo que deberá configurarlo en esta página.
Para el **tiempo de ejecución de Resolver**, selecciona `APPSYNC_JS` habilitar el JavaScript tiempo de ejecución.
1. Puede habilitar el [almacenamiento en caché](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) para esta API. También recomendamos desactivar esta característica por el momento. Seleccione **Crear**.
1. En la página **Editar solucionador**, hay un editor de código llamado **Código de solucionador** que le permite implementar la lógica para el controlador y la respuesta del solucionador (antes y después de los pasos). Para obtener más información, consulte la [descripción general de los JavaScript resolutores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
**nota**
En nuestro ejemplo, vamos a dejar la solicitud en blanco y la respuesta establecida para devolver el último resultado del origen de datos del [contexto](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html):
```
import {util} from '@aws-appsync/utils';
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Bajo esta sección, hay una tabla llamada **Funciones**. Las funciones permiten implementar código que se puede reutilizar en varios solucionadores. En lugar de tener que reescribir o copiar el código constantemente, puede almacenar el código fuente como una función para añadirla a un solucionador siempre que lo necesite.
Las funciones constituyen la mayor parte de la lista de operaciones de una canalización. Al utilizar varias funciones en un solucionador, se establece el orden de las funciones y estas se ejecutan en ese orden en secuencia. Se ejecutan después de la función de solicitud y antes de que comience la función de respuesta.
Para añadir una función nueva, en **Funciones**, seleccione **Añadir función** y, a continuación, **Crear nueva función**. Como alternativa, puede que vea el botón **Crear función** para seleccionarlo.
1. Elija un origen de datos. Será el origen de datos en el que actuará el solucionador.
**nota**
En nuestro ejemplo, asociamos un solucionador para `getPost`, que recupera un objeto `Post` según el `id`. Supongamos que ya hemos configurado una tabla de DynamoDB para este esquema. Su clave de partición está establecida en `id` y está vacía.
1. Introduzca un `Function name`.
1. En **Código de función**, deberá implementar el comportamiento de la función. Esto puede resultar confuso, pero cada función tendrá su propio controlador local de solicitudes y respuestas. Se ejecuta la solicitud, luego se invoca el origen de datos para gestionar la solicitud y, a continuación, el controlador de respuestas procesa la respuesta del origen de datos. El resultado se almacena en el objeto de [contexto](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html). Después, se ejecutará la siguiente función de la lista o se pasará al controlador de respuestas posterior al paso si es el último.
**nota**
En nuestro ejemplo, asociamos un solucionador a `getPost`, que obtiene una lista de objetos `Post` del origen de datos. Nuestra función de solicitud solicitará los datos de nuestra tabla, la tabla pasará su respuesta al contexto (ctx) y, a continuación, la respuesta devolverá el resultado en el contexto. AWS AppSync Su punto fuerte reside en su interconexión con otros servicios. AWS Dado que utilizamos DynamoDB, tenemos un [conjunto de operaciones](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) para simplificar este tipo de acciones. También tenemos algunos ejemplos repetitivos para otros tipos de orígenes de datos.
Nuestro código será como este:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
En este paso, hemos añadido dos funciones:
`request`: el controlador de solicitudes realiza la operación de recuperación en el origen de datos. El argumento contiene el objeto de contexto (`ctx`) o datos que están disponibles para todos los solucionadores que realizan una operación determinada. Por ejemplo, puede contener datos de autorización, los nombres de los campos que se están resolviendo, etc. La instrucción return realiza una operación [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) (vea ejemplos [aquí](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html)). Dado que trabajamos con DynamoDB, podemos usar algunas de las operaciones de ese servicio. El escaneo realiza una búsqueda básica de todos los elementos de nuestra tabla. El resultado de esta operación se almacena en el objeto de contexto como un contenedor de `result` antes de pasarlo al controlador de respuestas. La `request` se ejecuta antes de la respuesta en la canalización.
`response`: el controlador de respuestas que devuelve la salida de `request`. El argumento es el objeto de contexto actualizado y la declaración de retorno es `ctx.prev.result`. En este punto de la guía, es posible que no esté familiarizado con este valor. `ctx` hace referencia al objeto de contexto. `prev`, a la operación anterior en la canalización, que era nuestra `request`. `result` contiene los resultados del solucionador a medida que se desplaza por la canalización. Si lo junta todo, `ctx.prev.result` devuelve el resultado de la última operación realizada, que fue el controlador de solicitudes.
1. Cuando haya terminado, elija **Crear**.
1. De vuelta a la pantalla de solucionador, en **Funciones**, seleccione el menú desplegable **Añadir función** y añada la función a su lista de funciones.
1. Seleccione **Guardar** para actualizar el solucionador.
------
#### [ CLI ]
**Para añadir su función**
+ Cree una función para su solucionador de canalizaciones mediante el comando `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`.
Para este comando en particular, deberá introducir varios parámetros:
1. El `api-id` de su API.
1. El `name` de la función de la consola. AWS AppSync
1. El `data-source-name` o el nombre del origen de datos que la función utilizará. Ya debe estar creado y vinculado a su API de GraphQL en el servicio de AWS AppSync .
1. El `runtime` o el entorno y el idioma de la función. Para JavaScript, el nombre debe ser`APPSYNC_JS`, y el tiempo de ejecución,`1.0.0`.
1. El `code` o los controladores de solicitud y respuesta de su función. Si bien puede escribirlo manualmente, es mucho más fácil agregarlo a un archivo.txt (o un formato similar) y luego pasarlo como argumento.
**nota**
Nuestro código de consulta estará en un archivo que se transfiere como argumento:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Un comando de ejemplo puede tener este aspecto:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name get_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file://~/path/to/file/{filename}.{fileType}
```
Aparecerá un resultado en la CLI. A continuación se muestra un ejemplo:
```
{
"functionConfiguration": {
"functionId": "ejglgvmcabdn7lx75ref4qeig4",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4",
"name": "get_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
**nota**
Asegúrese de grabar el `functionId` en algún lugar, ya que se utilizará para asociar la función al solucionador.
**Para crear su primer solucionador**
+ Cree una función de canalización para `Query` ejecutando el comando `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)`.
Para este comando en particular, deberá introducir varios parámetros:
1. El `api-id` de su API.
1. El `type-name` o el tipo de objeto especial de su esquema (consulta, mutación, suscripción).
1. El `field-name` o la operación de campo de dentro del tipo de objeto especial al que desee asociar el solucionador.
1. El `kind`, que especifica un solucionador unitario o de canalización. Configúrelo en `PIPELINE` para habilitar las funciones de canalización.
1. La `pipeline-config` o las funciones que se van a asociar al solucionador. Asegúrese de conocer los valores de `functionId` de sus funciones. El orden de la lista es importante.
1. El`runtime`, que era `APPSYNC_JS` (JavaScript). La `runtimeVersion` actualmente es `1.0.0`.
1. El `code`, que contiene los controladores de los pasos de antes y de después.
**nota**
Nuestro código de consulta estará en un archivo que se transfiere como argumento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Un comando de ejemplo puede tener este aspecto:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Query \
--field-name getPost \
--kind PIPELINE \
--pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Aparecerá un resultado en la CLI. A continuación se muestra un ejemplo:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "getPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"ejglgvmcabdn7lx75ref4qeig4"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**sugerencia**
[Antes de utilizar la CDK, le recomendamos que consulte la [documentación oficial](https://docs.aws.amazon.com/cdk/v2/guide/home.html) de la CDK junto con AWS AppSync su referencia.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Los pasos que se indican a continuación solo mostrarán un ejemplo general del fragmento de código utilizado para añadir un recurso concreto. **No** se pretende que esta sea una solución funcional en su código de producción. También, se presupone que ya tiene una aplicación en funcionamiento.
Una aplicación básica necesitará lo siguiente:
1. Directivas de importación de servicios
1. Código de esquema
1. Generador de orígenes de datos
1. Código de función
1. Código de solucionador
En las secciones [Diseñar el esquema](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) y [Asociar un origen de datos](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html), sabemos que el archivo de pila incluirá las directivas de importación del siguiente formato:
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
**nota**
En las secciones anteriores, solo explicamos cómo importar AWS AppSync componentes fijos. En código real, deberá importar más servicios simplemente para ejecutar la aplicación. En nuestro ejemplo, si tuviéramos que crear una aplicación CDK muy sencilla, al menos importaríamos el AWS AppSync servicio junto con nuestra fuente de datos, que era una tabla de DynamoDB. También necesitaríamos importar otros constructos para implementar la aplicación:
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
Resumamos cada uno de estos elementos:
`import * as cdk from 'aws-cdk-lib';`: permite definir la aplicación del CDK y sus constructos, como la pila. También contiene funciones de utilidad útiles para nuestra aplicación, como la manipulación de metadatos. Si conoce esta directiva de importación, pero se pregunta por qué la biblioteca principal de cdk no se utiliza aquí, consulte la página [Migración](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html).
`import * as appsync from 'aws-cdk-lib/aws-appsync';`: importa el [servicio de AWS AppSync](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html).
`import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';`: importa el [servicio de DynamoDB](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html).
`import { Construct } from 'constructs';`: lo necesitamos para definir el [constructo](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html) raíz.
El tipo de importación depende de los servicios que llame. Te recomendamos consultar la documentación del CDK para ver ejemplos. El esquema de la parte superior de la página será un archivo independiente en su aplicación de CDK, en forma de archivo `.graphql`. En el archivo de pila, podemos asociarlo a un nuevo GraphQL mediante el siguiente formulario:
```
const add_api = new appsync.GraphqlApi(this, 'graphQL-example', {
name: 'my-first-api',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')),
});
```
**nota**
En el ámbito `add_api`, añadiremos una nueva API de GraphQL con la palabra clave `new` seguida de `appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)`. Nuestro ámbito es `this`, el identificador de CFN es `graphQL-example`, y nuestros accesorios son `my-first-api` (nombre de la API en la consola) y `schema.graphql` (la ruta absoluta al archivo de esquema).
Para añadir un origen de datos, añádala primero a la pila. Luego, asóciela a la API de GraphQL mediante el método específico del origen. La asociación se producirá cuando ponga en funcionamiento su solucionador. Mientras tanto, usemos un ejemplo para crear la tabla de DynamoDB con `dynamodb.Table`:
```
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
```
**nota**
Si usáramos esto en nuestro ejemplo, añadiríamos una nueva tabla de DynamoDB con el identificador de CFN de `posts-table` y una clave de partición de `id (S)`.
A continuación, debemos implementar nuestro solucionador en el archivo de pila. A continuación, se muestra un ejemplo de una consulta sencilla que busca todos los elementos de una tabla de DynamoDB:
```
const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', {
name: 'get_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
add_api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
```
**nota**
En primer lugar, creamos una función llamada `add_func`. Este orden de creación puede parecer un poco contradictorio, pero hay que crear las funciones en el solucionador de canalizaciones antes de crear el solucionador propiamente dicho. Una función tiene el siguiente formato:
```
AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)
```
Nuestro alcance era `this`, nuestro identificador de CFN era `func-get-posts` y nuestros accesorios contenían los detalles reales de la función. Dentro de los accesorios, hemos incluido:
La `name` de la función que estará presente en la AWS AppSync consola (). `get_posts_func_1`
La API de GraphQL que hemos creado antes (`add_api`).
El origen de datos; este es el punto en el que vinculamos el origen de datos al valor de la API GraphQL y, a continuación, la asociamos a la función. Tomamos la tabla que hemos creado (`add_ddb_table`) y la asociamos a la API GraphQL (`add_api`) mediante uno de los métodos de `GraphqlApi` ([https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options)). El valor del identificador (`table-for-posts`) es el nombre del origen de datos de la consola de AWS AppSync . Para obtener una lista de métodos específicos del origen, consulte las páginas siguientes:
[ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
[ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
[ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
[ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
[ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
[ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
[ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
El código contiene los controladores de solicitudes y respuestas de nuestra función, que son fáciles de escanear y devolver.
El tiempo de ejecución especifica que queremos usar la versión 1.0.0 del tiempo de ejecución APPSYNC\$1JS. Tenga en cuenta que actualmente esta es la única versión disponible para APPSYNC\$1JS.
Luego, debemos asociar la función al solucionador de canalización. Hemos creado nuestro solucionador usando este formulario:
```
Resolver(scope: Construct, id: string, props: ResolverProps)
```
Nuestro alcance era `this`, nuestro identificador de CFN era `pipeline-resolver-get-posts` y nuestros accesorios contenían los detalles reales de la función. Dentro de los accesorios, hemos incluido:
La API de GraphQL que hemos creado antes (`add_api`).
El nombre del tipo de objeto especial; se trata de una operación de consulta, por lo que simplemente hemos añadido el valor `Query`.
El nombre de campo (`getPost`) es el nombre del campo del esquema en el tipo `Query`.
El código contiene sus controladores de antes y después. Nuestro ejemplo simplemente devuelve los resultados que estaban en el contexto después de que la función realizara su operación.
El tiempo de ejecución especifica que queremos usar la versión 1.0.0 del tiempo de ejecución APPSYNC\$1JS. Tenga en cuenta que actualmente esta es la única versión disponible para APPSYNC\$1JS.
La configuración de la canalización contiene la referencia a la función que hemos creado (`add_func`).
------
Para resumir lo que ocurrió en este ejemplo, vio una AWS AppSync función que implementaba un controlador de solicitudes y respuestas. La función se ha encargado de interactuar con el origen de datos. El controlador de solicitudes envió una `Scan` operación a AWS AppSync, indicándole qué operación debía realizar en la fuente de datos de DynamoDB. El controlador de respuestas ha devuelto la lista de elementos (`ctx.result.items`). A continuación, la lista de elementos se ha asignado automáticamente al tipo GraphQL de `Post`.
## Creación de solucionadores de mutaciones básicos
En esta sección se mostrará cómo crear un solucionador de mutaciones básico.
------
#### [ 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 sección **Solucionadores** y el tipo **Mutación**, seleccione **Asociar** junto al campo.
**nota**
En nuestro ejemplo, vamos a asociar un solucionador para `createPost`, que añade un objeto `Post` a nuestra table. Supongamos que utilizamos la misma tabla de DynamoDB de la última sección. Su clave de partición está establecida en `id` y está vacía.
1. En la página **Asociar solucionador**, en **Tipo de solucionador**, elija `pipeline resolvers`. Le recordamos que puede encontrar más información sobre los solucionadores [aquí](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html). Para el **tiempo de ejecución de Resolver**, selecciona `APPSYNC_JS` habilitar el JavaScript tiempo de ejecución.
1. Puede habilitar el [almacenamiento en caché](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) para esta API. También recomendamos desactivar esta característica por el momento. Seleccione **Crear**.
1. Seleccione **Añadir función** y, a continuación, **Crear nueva función**. Como alternativa, puede que vea el botón **Crear función** para seleccionarlo.
1. Elija el origen su origen de datos. Debería ser el origen cuyos datos va a manipular con la mutación.
1. Introduzca un `Function name`.
1. En **Código de función**, deberá implementar el comportamiento de la función. Se trata de una mutación, por lo que lo ideal es que la solicitud realice alguna operación de cambio de estado en el origen de datos invocado. La función de respuesta procesará el resultado.
**nota**
`createPost` va a añadir o “poner” una nueva `Post` en la tabla con nuestros parámetros como datos. Podríamos añadir algo parecido a esto:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
En este paso, hemos añadido también las funciones `request` y `response`:
`request`: el controlador de solicitudes acepta el contexto como argumento. La instrucción return del controlador de solicitudes ejecuta un comando [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem), que es una operación de DynamoDB integrada (consulte [aquí](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html) o [aquí](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) para ver ejemplos). El comando `PutItem` añade un objeto de `Post` a nuestra tabla de DynamoDB tomando el valor `key` de la partición (generado automáticamente por `util.autoid()`) y los `attributes` de la entrada del argumento de contexto (son los valores que transferiremos en nuestra solicitud). La `key` es el `id` y `attributes` son los argumentos de los campos `date` y `title`. Ambos se preformatean mediante el elemento auxiliar [https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js](https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js) para que funcionen con la tabla de DynamoDB.
`response`: la respuesta acepta el contexto actualizado y devuelve el resultado del controlador de solicitudes.
1. Cuando haya terminado, elija **Crear**.
1. De vuelta a la pantalla de solucionador, en **Funciones**, seleccione el menú desplegable **Añadir función** y añada la función a su lista de funciones.
1. Seleccione **Guardar** para actualizar el solucionador.
------
#### [ CLI ]
**Para añadir su función**
+ Cree una función para su solucionador de canalizaciones mediante el comando `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`.
Para este comando en particular, deberá introducir varios parámetros:
1. El `api-id` de su API.
1. El `name` de la función de la AWS AppSync consola.
1. El `data-source-name` o el nombre del origen de datos que la función utilizará. Ya debe estar creado y vinculado a su API de GraphQL en el servicio de AWS AppSync .
1. El `runtime` o el entorno y el idioma de la función. Para JavaScript, el nombre debe ser`APPSYNC_JS`, y el tiempo de ejecución,`1.0.0`.
1. El `code` o los controladores de solicitud y respuesta de su función. Si bien puede escribirlo manualmente, es mucho más fácil añadirlo a un archivo.txt (o un formato similar) y luego transferirlo como argumento.
**nota**
Nuestro código de consulta estará en un archivo que se transfiere como argumento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Un comando de ejemplo puede tener este aspecto:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name add_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Aparecerá un resultado en la CLI. A continuación se muestra un ejemplo:
```
{
"functionConfiguration": {
"functionId": "vulcmbfcxffiram63psb4dduoa",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa",
"name": "add_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output foes here"
}
}
```
**nota**
Asegúrese de grabar el `functionId` en algún lugar, ya que se utilizará para asociar la función al solucionador.
**Para crear su primer solucionador**
+ Cree una función de canalización para `Mutation` ejecutando el comando `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)`.
Para este comando en particular, deberá introducir varios parámetros:
1. El `api-id` de su API.
1. El `type-name` o el tipo de objeto especial de su esquema (consulta, mutación, suscripción).
1. El `field-name` o la operación de campo de dentro del tipo de objeto especial al que desee asociar el solucionador.
1. El `kind`, que especifica un solucionador unitario o de canalización. Configúrelo en `PIPELINE` para habilitar las funciones de canalización.
1. La `pipeline-config` o las funciones que se van a asociar al solucionador. Asegúrese de conocer los valores de `functionId` de sus funciones. El orden de la lista es importante.
1. El`runtime`, que era `APPSYNC_JS` (JavaScript). La `runtimeVersion` actualmente es `1.0.0`.
1. El `code`, que contiene los pasos de antes y de después.
**nota**
Nuestro código de consulta estará en un archivo que se transfiere como argumento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Un comando de ejemplo puede tener este aspecto:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Mutation \
--field-name createPost \
--kind PIPELINE \
--pipeline-config functions=vulcmbfcxffiram63psb4dduoa \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Aparecerá un resultado en la CLI. A continuación se muestra un ejemplo:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "createPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"vulcmbfcxffiram63psb4dduoa"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**sugerencia**
[Antes de utilizar la CDK, le recomendamos que consulte la [documentación oficial](https://docs.aws.amazon.com/cdk/v2/guide/home.html) de la CDK junto con AWS AppSync su referencia.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
Los pasos que se indican a continuación solo mostrarán un ejemplo general del fragmento de código utilizado para añadir un recurso concreto. **No** se pretende que esta sea una solución funcional en su código de producción. También, se presupone que ya tiene una aplicación en funcionamiento.
+ Para realizar una mutación, si usted se encuentra en el mismo proyecto, puede añadirla al archivo de pila como la consulta. Esta es una función modificada y un solucionador para una mutación que añade una nueva `Post` a la tabla:
```
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
add_api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
```
**nota**
Como esta mutación y la consulta tienen una estructura similar, nos limitaremos a explicar los cambios que hemos hecho para realizar la mutación.
En la función, hemos cambiado el identificador de CFN por `func-add-post` y el nombre por `add_posts_func_1` a para reflejar el hecho de que estamos añadiendo `Posts` a la tabla. En la fuente de datos, hicimos una nueva asociación con nuestra tabla (`add_ddb_table`) de la AWS AppSync consola, `table-for-posts-2` ya que el `addDynamoDbDataSource` método así lo requiere. Tenga en cuenta que esta nueva asociación sigue utilizando la misma tabla que creamos anteriormente, pero ahora tenemos dos conexiones a ella en la AWS AppSync consola: una para la consulta as `table-for-posts` y otra para la mutación as`table-for-posts-2`. El código se ha modificado para añadir una `Post` mediante la generación automática de su valor de `id` y la aceptación de la entrada de un cliente para el resto de los campos.
En el solucionador, hemos cambiado el valor del identificador por `pipeline-resolver-create-posts` para reflejar el hecho de que estamos añadiendo `Posts` a la tabla. Para reflejar la mutación en el esquema, se cambiado el nombre del tipo por `Mutation`, y el nombre, `createPost`. La configuración de la canalización se ha establecido en nuestra nueva función de mutación `add_func_2`.
------
Para resumir lo que ocurre en este ejemplo, convierte AWS AppSync automáticamente los argumentos definidos en el `createPost` campo del esquema de GraphQL en operaciones de DynamoDB. El ejemplo almacena los registros en DynamoDB mediante una clave de `id`, que se crea automáticamente con nuestro texto auxiliar `util.autoId()`. Todos los demás campos que pase a los argumentos de contexto (`ctx.args.input`) a partir de solicitudes realizadas en la AWS AppSync consola o de otro modo se almacenarán como atributos de la tabla. Tanto la clave como los atributos se asignan automáticamente a un formato de DynamoDB compatible mediante el texto auxiliar `util.dynamodb.toMapValues(values)`.
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 invocarlo. De forma opcional, puede ver la solicitud completa en un origen de datos de forma interactiva cuando ejecute una consulta. [Para obtener más información, consulte [Probar y depurar solucionadores (JavaScript) y Supervisión y registro](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html).](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring)
## Solucionadores avanzados
Si sigue la sección de paginación opcional de [Diseño del esquema](designing-your-schema.md#aws-appsync-designing-your-schema), deberá añadir el solucionador a la solicitud para poder utilizar la paginación. En nuestro ejemplo, se ha utilizado una paginación de consultas llamada `getPosts` para devolver solo una parte de los elementos solicitados a la vez. Nuestro código de solucionador en ese campo puede ser como este:
```
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
const { limit = 20, nextToken } = ctx.args;
return { operation: 'Scan', limit, nextToken };
}
/**
* @returns the result of the `put` operation
*/
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
En la solicitud, transferimos el contexto de esta. `limit`El nuestro es*20*, lo que significa que devolvemos hasta 20 `Posts` en la primera consulta. Nuestro cursor `nextToken` está fijo en la primera entrada de `Post` en el origen de datos. Se transfieren a los argumentos. A continuación, la solicitud escanea desde la primera `Post` hasta el número límite de escaneo. El origen de datos almacena el resultado en el contexto, que se transfiere a la respuesta. La respuesta devuelve las `Posts` recuperadas y, a continuación, establece el `nextToken` en la entrada de la `Post` que se encuentra justo después del límite. La siguiente solicitud se envía para hacer exactamente lo mismo, pero empezando por el desplazamiento justo después de la primera consulta. Tenga en cuenta que este tipo de solicitudes se realizan de forma secuencial y no en paralelo.
# Probar y depurar resolutores en AWS AppSync () JavaScript
AWS AppSync ejecuta resolutores en un campo GraphQL contra una fuente de datos. Cuando se trabaja con solucionadores de canalizaciones, las funciones interactúan con los orígenes de datos. Como se describe en la [descripción general de los JavaScript resolutores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html), las funciones se comunican con las fuentes de datos mediante controladores de solicitudes y respuestas escritos JavaScript y que se ejecutan en tiempo de ejecución. `APPSYNC_JS` Esto le permite proporcionar lógica y condiciones personalizadas antes y después de comunicarse con el origen de datos.
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 toda la solicitud de Amazon CloudWatch. 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 útil sobre la solicitud. Por ejemplo, contiene los argumentos de un cliente, información de identidad y datos del campo principal de GraphQL. También almacena los resultados del origen de datos, que puede usar en el controlador de respuestas. Si desea más información acerca de esta estructura y las utilidades auxiliares disponibles para programar, consulte [Resolver context object reference](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html).
Al escribir o editar una función de 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 los controladores de solicitudes y de respuestas 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 de control**, elige tu API de GraphQL.
1. En la **barra lateral**, seleccione **Funciones**.
1. Seleccione una función existente.
1. En la parte superior de la página **Actualizar función**, 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 **Configurar contexto de prueba** que aparece a continuación.
1. Introduzca un **Nombre de contexto de texto**.
1. Seleccione el botón **Guardar**.
1. Para evaluar el solucionador con el objeto de contexto simulado, elija **Run Test (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. En el siguiente fragmento de código se muestra el aspecto que podría tener el esquema:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Puedes escribir una AWS AppSync función y añadirla a tu `addDog` resolución para gestionar la mutación. Para probar AWS AppSync la función, puede rellenar un objeto de contexto, como en el siguiente ejemplo. 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"
}
}
```
Puedes probar la AWS AppSync función con el siguiente código:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id: util.autoId() }),
attributeValues: util.dynamodb.toMapValues(ctx.args),
};
}
export function response(ctx) {
if (ctx.identity.username === 'Nadia') {
console.log("This request is allowed")
return ctx.result;
}
util.unauthorized();
}
```
El controlador de solicitudes y respuestas evaluado tiene los datos de su objeto de contexto de prueba y el valor generado de `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 los controladores de solicitudes y respuestas con AWS AppSync APIs
Puede usar el comando de API `EvaluateCode` para probar el código de forma remota con datos simulados. Para empezar a usar el comando, asegúrese de haber añadido el permiso `appsync:evaluateMappingCode` a su política. Por ejemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Puede aprovechar el comando utilizando 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 controladores de solicitudes y respuestas de AWS AppSync funciones de la sección anterior. Con la CLI de la estación local, guarde el código en un archivo denominado `code.js` 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-code \
--code file://code.js \
--function response \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
La respuesta contiene un `evaluationResult` que incluye la carga útil devuelta por el controlador. También contiene un objeto `logs` que incluye la lista de registros generados por el controlador durante la evaluación. Esto facilita la depuración de la ejecución de código y la consulta de información sobre la evaluación como ayuda para solucionar problemas. Por ejemplo:
```
{
"evaluationResult": "{\"breed\":\"Miniature Schnauzer\",\"color\":\"black_grey\"}",
"logs": [
"INFO - code.js:13:5: \"This request is allowed\""
]
}
```
El `evaluationResult` se puede analizar como JSON, lo que da como resultado:
```
{
"breed": "Miniature Schnauzer",
"color": "black_grey"
}
```
Cuando se utiliza el SDK, puede incorporar fácilmente pruebas de su conjunto de pruebas favorito para validar el comportamiento de los controladores. 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' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).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 totalTime: 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 un momento, 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 resolutores de canalización en AWS AppSync () JavaScript
AWS AppSync ejecuta resolutores en un campo de 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.
[Para obtener más información sobre la arquitectura de un solucionador de JavaScript canalización, consulta la descripción general de los JavaScript resolutores.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html#anatomy-of-a-pipeline-resolver-js)
## Paso 1: creación de un solucionador de canalización
En la AWS AppSync consola, vaya 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`. Configura el solucionador en `pipeline resolver` y el tiempo de ejecución en `APPSYNC_JS` y, a continuación, crea el solucionador.
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. Controlador de solicitudes de solucionador Mutation.signUp
1. Función validateEmail
1. Función saveUser
1. Controlador de respuestas 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)`.
Actualice su código de solucionador sustituyendo sus funciones de solicitud y respuesta:
```
export function request(ctx) {
ctx.stash.email = ctx.args.input.email
return {};
}
export function response(ctx) {
return ctx.prev.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.
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 a función**, escriba `validateEmail`. En el área de **código de la función**, sobrescriba todo con este fragmento:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { email } = ctx.stash;
const valid = util.matches(
'^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com',
email
);
if (!valid) {
util.error(`"${email}" is not a valid email.`);
}
return { payload: { email } };
}
export function response(ctx) {
return ctx.result;
}
```
Revise la información indicada y, a continuación, seleccione **Crear**. Acabamos de crear nuestra función **validateEmail**. Repita estos pasos para crear la función **SaveUser** con el siguiente código (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):
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return ctx.prev.result;
}
export function response(ctx) {
ctx.result.id = util.autoId();
return 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 `signUp` 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
username
}
}
```
Debería devolver algo parecido a esto:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"username": "nadia"
}
}
}
```
Hemos registrado correctamente nuestro usuario y validado el correo electrónico de entrada utilizando un solucionador de canalización.