Creando tu GraphQL API Definir una publicación básica API Configuración de la tabla de Amazon DynamoDB Configuración de un addPost solucionador (Amazon DynamoDB PutItem)Configuración del getPost solucionador (Amazon DynamoDB GetItem)Crear una updatePost mutación (Amazon DynamoDB UpdateItem)Crear mutaciones de votos (Amazon DynamoDB UpdateItem)Configuración de un deletePost solucionador (Amazon DynamoDB DeleteItem)Configuración de una allPost resolución (Amazon DynamoDB Scan)Configuración de una resolución de allPostsBy autor (Amazon DynamoDB Query)Uso de conjuntos Conclusión

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

En este tutorial, importará sus tablas de Amazon DynamoDB y las conectará AWS AppSync para crear un API GraphQL completamente funcional mediante solucionadores de canalización que puede JavaScript utilizar en su propia aplicación.

Utilizará la AWS AppSync consola para aprovisionar sus recursos de Amazon DynamoDB, crear sus resolutores y conectarlos a sus fuentes de datos. También podrá leer y escribir en la base de datos de Amazon DynamoDB a través de instrucciones de GraphQL y suscribirse a datos en tiempo real.

Existen pasos específicos que deben completarse para que las instrucciones de GraphQL se traduzcan a operaciones de Amazon DynamoDB y para que las respuestas se vuelvan a traducir a GraphQL. En este tutorial se describe el proceso de configuración a través de varios escenarios y patrones de acceso a datos del mundo real.

Creando tu GraphQL API

Para crear un GraphQL API en AWS AppSync

Abre la AppSync consola y selecciona Crear API.
Seleccione Diseñar desde cero y elija Siguiente.
Asigne un nombre a su nombre y APIPostTutorialAPI, a continuación, seleccione Siguiente. Vaya a la página de revisión dejando el resto de las opciones con sus valores predeterminados y seleccione Create.

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

Definir una publicación básica API

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

Para añadir datos a su esquema

En la tuyaAPI, selecciona la pestaña Esquema.

Crearemos un esquema que defina un tipo Post y una operación addPost para añadir y obtener objetos Post. En la página Esquema, sustituya el contenido por el código siguiente:


schema {
    query: Query
    mutation: Mutation
}

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

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

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

Elija Save Schema (Guardar esquema).

Configuración de la tabla de Amazon DynamoDB

La AWS AppSync consola puede ayudarle a aprovisionar los AWS recursos necesarios para almacenar sus propios recursos en una tabla de Amazon DynamoDB. En este paso, creará una tabla de Amazon DynamoDB para almacenar sus publicaciones. También configurará un índice secundario que utilizaremos más adelante.

Para crear una tabla de Amazon DynamoDB

En la página Esquema, seleccione Crear recursos.
Elija Usar tipo existente y, a continuación, elija el tipo Post.
En la sección Índices secundarios, elija Añadir índice.
Llame al índice author-index.
Establezca el Primary key en author y la clave Sort en None.
Deshabilite Generación automática de GraphQL. En este ejemplo, vamos a crear el solucionador nosotros mismos.
Seleccione Crear.

Ahora tiene un nuevo origen de datos llamado PostTable, que puede ver en Orígenes de datos en la pestaña lateral. Este origen de datos se utiliza para vincular las consultas y mutaciones a la tabla de Amazon DynamoDB.

Configuración de un addPost solucionador (Amazon DynamoDB PutItem)

Ahora que AWS AppSync conoce la tabla Amazon DynamoDB, puede vincularla a consultas y mutaciones individuales definiendo resolutores. La primera resolución que cree es la resolución de addPost canalización que utiliza JavaScript, que le permite crear una publicación en la tabla de Amazon DynamoDB. Un solucionador de canalización tiene los siguientes componentes:

La ubicación en el esquema de GraphQL donde se asocia el solucionador. En este caso configuramos en el campo createPost un solucionador de tipo Mutation. El solucionador se invocará cuando el intermediario llame a la mutación { addPost(...){...} }.
El origen de datos que se va a utilizar para el solucionador. En este caso, queremos utilizar el origen de datos de DynamoDB definido anteriormente para poder añadir entradas en la tabla post-table-for-tutorial de DynamoDB.
El controlador de solicitudes. El controlador de solicitudes es una función que gestiona la solicitud entrante de la persona que llama y la traduce en instrucciones AWS AppSync para ejecutarlas en DynamoDB.
El controlador de respuestas. El cometido del controlador de respuestas es gestionar la respuesta de DynamoDB y traducirla de nuevo a algo que GraphQL espera. Esto resulta útil si la forma de los datos en DynamoDB es diferente del tipo Post en GraphQL. Como este caso sí tienen la misma forma, solo hay que transmitir los datos.

Para configurar el solucionador

En la suyaAPI, elija la pestaña Esquema.
En el panel Solucionadores, busque el campo addPost debajo del tipo Mutation y, a continuación, seleccione Asociar.
Elija el origen de datos y, a continuación, seleccione Crear.

En su editor de código, reemplace el código por este fragmento:


import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	const item = { ...ctx.arguments, ups: 1, downs: 0, version: 1 }
	const key = { id: ctx.args.id ?? util.autoId() }
	return ddb.put({ key, item })
}

export function response(ctx) {
	return ctx.result
}

Seleccione Guardar.

nota

En este código, se emplean las utilidades del módulo de DynamoDB que permiten crear fácilmente solicitudes de DynamoDB.

AWS AppSync viene con una utilidad para la generación automática de ID llamadautil.autoId(), que se utiliza para generar una ID para tu nueva publicación. Si no especifica un identificador, la utilidad lo generará automáticamente.


const key = { id: ctx.args.id ?? util.autoId() }

Para obtener más información sobre las utilidades disponibles JavaScript, consulte las características JavaScript de tiempo de ejecución para resoluciones y funciones.

Llámalos API para añadir una publicación

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

Para ejecutar la operación

En la suyaAPI, seleccione la pestaña Consultas.

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


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija addPost. Los resultados de la publicación que acaba de crear deben aparecer en el panel Resultados a la derecha del panel Consultas. Debería parecerse a lo que sigue:


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

La siguiente explicación muestra lo que ocurrió:

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

AWS AppSync ejecuta el gestor de solicitudes del solucionador. La función ddb.put crea una solicitud PutItem similar a la siguiente:


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

AWS AppSync utiliza este valor para generar y ejecutar una solicitud de Amazon PutItem DynamoDB.

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


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

El controlador de respuestas devuelve el resultado inmediatamente (return ctx.result).
El resultado final es visible en la respuesta de GraphQL.

Configuración del getPost solucionador (Amazon DynamoDB GetItem)

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

Para añadir su solucionador

En suAPI, elija la pestaña Esquema.
En el panel Solucionadores a la derecha, busque el campo getPost en el tipo Query y, a continuación, seleccione Asociar.
Elija el origen de datos y, a continuación, seleccione Crear.

En el editor de código, sustituya el código por este fragmento:


import * as ddb from '@aws-appsync/utils/dynamodb'
	
export function request(ctx) {
	return ddb.get({ key: { id: ctx.args.id } })
}

export const response = (ctx) => ctx.result

Guarde el solucionador.

nota

En este solucionador, utilizamos una expresión de función de flecha para el controlador de respuestas.

APILlámalos para conseguir una publicación

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

Para ejecutar su consulta

En la suyaAPI, seleccione la pestaña Consultas.

En el panel Consultas, añada el siguiente código y use el identificador que copió después de crear su publicación:


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija getPost. Los resultados de la publicación que acaba de crear deben aparecer en el panel Resultados a la derecha del panel Consultas.

Los resultados obtenidos de Amazon DynamoDB deben aparecer en el panel Resultados a la derecha del panel Consultas. Debería parecerse a lo que sigue:


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

Como alternativa, vamos a tomar el siguiente ejemplo:


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

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


import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	return ddb.get({
		key: { id: ctx.args.id },
		projection: ['author', 'id', 'title'],
	})
}

export const response = (ctx) => ctx.result

También puedes usar un signo selectionSetListgetPostpara representar lo siguienteexpression:


import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	const projection = ctx.info.selectionSetList.map((field) => field.replace('/', '.'))
	return ddb.get({ key: { id: ctx.args.id }, projection })
}

export const response = (ctx) => ctx.result

Crear una updatePost mutación (Amazon DynamoDB UpdateItem)

De momento, ya sabe crear y recuperar objetos Post en Amazon DynamoDB. A continuación, va a configurar una nueva mutación para actualizar objetos. En comparación con la mutación addPost, que requiere que se especifiquen todos los campos, esta mutación le permite especificar solo los campos que desea cambiar. También introdujo un nuevo argumento expectedVersion que permite especificar la versión que se quiere modificar. Va a configurar una condición que garantice que está modificando la versión más reciente del objeto. Para ello, utilizará la operación UpdateItem de Amazon DynamoDB.

Para actualizar su solucionador

En la suyaAPI, elija la pestaña Esquema.

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


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

Elija Save Schema (Guardar esquema).

En el panel Solucionadores de la derecha, busque el campo updatePost recién creado en el tipo Mutation y, a continuación, seleccione Asociar. Cree su nuevo solucionador con el siguiente fragmento:


import { util } from '@aws-appsync/utils';
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const { id, expectedVersion, ...rest } = ctx.args;
  const values = Object.entries(rest).reduce((obj, [key, value]) => {
    obj[key] = value ?? ddb.operations.remove();
    return obj;
  }, {});

  return ddb.update({
    key: { id },
    condition: { version: { eq: expectedVersion } },
    update: { ...values, version: ddb.operations.increment(1) },
  });
}

export function response(ctx) {
  const { error, result } = ctx;
  if (error) {
    util.appendError(error.message, error.type);
  }
  return result;

Guarde los cambios que haya realizado.

Este solucionador utiliza ddb.update para crear una solicitud UpdateItem de Amazon DynamoDB. En lugar de escribir el elemento completo, solo pide a Amazon DynamoDB que actualice determinados atributos. Esto se consigue mediante expresiones de actualización de Amazon DynamoDB.

La función ddb.update toma como argumentos una clave y un objeto de actualización. A continuación, se comprueban los valores de los argumentos entrantes. Cuando un valor esté establecido en null, utilice la operación remove de DynamoDB para indicar que el valor debe eliminarse del elemento de DynamoDB.

También hay una nueva sección condition. Una expresión de condición le permite indicar AWS AppSync a Amazon DynamoDB si la solicitud debe realizarse correctamente o no en función del estado del objeto que ya estaba en Amazon DynamoDB antes de realizar la operación. En este caso, solo quiere que la solicitud UpdateItem se realice si el campo version del elemento que hay en Amazon DynamoDB coincide exactamente con el argumento expectedVersion. Cuando se actualice el elemento, queremos incrementar el valor de version. Esto es fácil de hacer con la función de operación increment.

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

Para obtener más información sobre la UpdateItem solicitud, consulte la UpdateItemdocumentación y la documentación del módulo DynamoDB.

Para obtener más información sobre cómo escribir expresiones de actualización, consulte la documentación de UpdateExpressionsDynamoDB.

Llámelos API para actualizar una publicación

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

Para actualizar el objeto

En tuAPI, selecciona la pestaña Consultas.

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


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija updatePost.

La publicación actualizada en Amazon DynamoDB debería aparecer en el panel Resultados a la derecha del panel Consultas. Debería parecerse a lo que sigue:


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

En esta solicitud, ha pedido a Amazon DynamoDB que actualice title únicamente los campos AWS AppSync y. content Todos los demás campos se han quedado como estaban (salvo por el incremento del campo version). Hemos establecido un nuevo valor en el atributo title y hemos eliminado el atributo content de la publicación. Los campos author, url, ups y downs no se han modificado. Intente ejecutar la solicitud de mutación de nuevo, dejándola exactamente como está. Verá una respuesta parecida a la siguiente:


{
  "data": {
    "updatePost": null
  },
  "errors": [
    {
      "path": [
        "updatePost"
      ],
      "data": null,
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "errorInfo": null,
      "locations": [
        {
          "line": 2,
          "column": 3,
          "sourceName": null
        }
      ],
      "message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 1RR3QN5F35CS8IV5VR4OQO9NNBVV4KQNSO5AEMVJF66Q9ASUAAJG)"
    }
  ]
}

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

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

Este método suele denominarse "bloqueo optimista".

Crear mutaciones de votos (Amazon DynamoDB UpdateItem)

El tipo Post contiene los campos ups y downs para permitir el registro de votos a favor y en contra. Sin embargo, en este momento, API no nos permite hacer nada con ellos. Vamos a añadir una mutación para votar a favor o en contra de las publicaciones.

Para añadir su mutación

En tuAPI, selecciona la pestaña Esquema.

En el panel Esquema, modifique el tipo Mutation y añada la enumeración DIRECTION para añadir nuevas mutaciones de votos:


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

enum DIRECTION {
  UP
  DOWN
}

Elija Save Schema (Guardar esquema).

En el panel Solucionadores de la derecha, busque el campo vote recién creado en el tipo Mutation y, a continuación, seleccione Asociar. Para crear un nuevo solucionador, cree y reemplace el código por el siguiente fragmento:


import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const field = ctx.args.direction === 'UP' ? 'ups' : 'downs';
  return ddb.update({
    key: { id: ctx.args.id },
    update: {
      [field]: ddb.operations.increment(1),
      version: ddb.operations.increment(1),
    },
  });
}

export const response = (ctx) => ctx.result;

Guarde los cambios que haya realizado.

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

Ahora que se han configurado los nuevos resolutores, AWS AppSync sabe cómo convertir una operación entrante upvotePost o una downvote mutación en una operación de Amazon DynamoDBUpdateItem. Ahora puede ejecutar mutaciones para votar a favor o en contra de la publicación que ha creado anteriormente.

Para ejecutar su mutación

En la suyaAPI, seleccione la pestaña Consultas.

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


mutation votePost {
  vote(id:123, direction: UP) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija votePost.

La publicación actualizada en Amazon DynamoDB debería aparecer en el panel Resultados a la derecha del panel Consultas. Debería parecerse a lo que sigue:


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

Seleccione Ejecutar unas cuantas veces más. Debería ver cómo se incrementan en 1 los campos ups y version cada vez que ejecuta la consulta.

Cambie la consulta para llamarla con una DIRECTION diferente.


mutation votePost {
  vote(id:123, direction: DOWN) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija votePost.

En esta ocasión, debería ver cómo se incrementan en 1 los campos downs y version cada vez que ejecuta la consulta.

Configuración de un deletePost solucionador (Amazon DynamoDB DeleteItem)

A continuación, hay que crear una mutación para eliminar una publicación. Para ello, utilizará la operación DeleteItem de Amazon DynamoDB.

Para añadir su mutación

En el esquema, seleccione la pestaña Esquema.

En el panel Esquema modifique el tipo Mutation para añadir una nueva mutación deletePost:


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

Esta vez, ha hecho que el campo expectedVersion sea opcional. Elija Guardar esquema.
En el panel Solucionadores de la derecha, busque el campo delete recién creado en el tipo Mutation y, a continuación, seleccione Asociar. Cree un nuevo solucionador con el siguiente código:
```
import { util } from '@aws-appsync/utils'

import { util } from '@aws-appsync/utils';
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  let condition = null;
  if (ctx.args.expectedVersion) {
    condition = {
      or: [
        { id: { attributeExists: false } },
        { version: { eq: ctx.args.expectedVersion } },
      ],
    };
  }
  return ddb.remove({ key: { id: ctx.args.id }, condition });
}

export function response(ctx) {
  const { error, result } = ctx;
  if (error) {
    util.appendError(error.message, error.type);
  }
  return result;
}
```
nota
El argumento expectedVersion es opcional. Si el intermediario ha establecido un argumento expectedVersion en la solicitud, entonces el controlador de solicitudes añade una condición que solo permitirá que la solicitud DeleteItem se atienda cuando el elemento se haya eliminado o cuando el atributo version de la publicación en Amazon DynamoDB coincida exactamente con expectedVersion. Si se omite, no se especificará ninguna expresión de condición para la solicitud DeleteItem. Se realizará correctamente independientemente del valor de version o de si el elemento existe o no en Amazon DynamoDB.
Aunque se trate de eliminar un elemento, puede devolver el elemento eliminado, siempre que no se haya eliminado previamente.

Para obtener más información sobre la DeleteItem solicitud, consulte la DeleteItemdocumentación.

Llama API al para eliminar una publicación

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

Para ejecutar su mutación

En la suyaAPI, seleccione la pestaña Consultas.

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


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija deletePost.

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


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

El valor solo se devuelve si esta llamada a deletePost es la que realmente lo elimina de Amazon DynamoDB. Vuelva a seleccionar Ejecutar.
La llamada se sigue ejecutando con éxito, pero no se devuelve ningún valor:
```
{
  "data": {
    "deletePost": null
  }
}
```
Ahora vamos a probar a eliminar una publicación, pero esta vez especificando expectedValue. Primero tiene que crear una nueva, porque acaba de eliminar la publicación con la que ha estado trabajando hasta ahora.

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


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija addPost.

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


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

Ahora, tratemos de eliminar esa publicación con un valor ilegal para. expectedVersion En el panel Consultas, pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente:
```
mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 9999
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija deletePost. Se devuelve el siguiente resultado:


{
  "data": {
    "deletePost": null
  },
  "errors": [
    {
      "path": [
        "deletePost"
      ],
      "data": null,
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "errorInfo": null,
      "locations": [
        {
          "line": 2,
          "column": 3,
          "sourceName": null
        }
      ],
      "message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 7083O037M1FTFRK038A4CI9H43VV4KQNSO5AEMVJF66Q9ASUAAJG)"
    }
  ]
}

La solicitud ha fallado porque la expresión de condición se evalúa como false. El valor version de la publicación en Amazon DynamoDB no coincide con el expectedValue especificado en los argumentos. El valor actual del objeto se devuelve en el campo data de la sección errors de la respuesta de GraphQL. Vuelva a intentar la solicitud, pero corrija expectedVersion:
```
mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 1
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija deletePost.

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


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

Vuelva a seleccionar Ejecutar. La llamada se sigue realizando correctamente, pero esta vez no se devuelve ningún valor, ya que la publicación ya se había eliminado en Amazon DynamoDB.
```
{ "data": { "deletePost": null } }
```

Configuración de una allPost resolución (Amazon DynamoDB Scan)

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

Para añadir su mutación

En tuAPI, elige la pestaña Esquema.

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


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

Añada un nuevo tipo PaginationPosts:


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

Elija Save Schema (Guardar esquema).
En el panel Solucionadores de la derecha, busque el campo allPost recién creado en el tipo Query y, a continuación, seleccione Asociar. Cree un nuevo solucionador con el siguiente código:
```
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const { limit = 20, nextToken } = ctx.arguments;
  return ddb.scan({ limit, nextToken });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}
```
El controlador de solicitudes de este solucionador espera dos argumentos opcionales:
- limit: especifica el número máximo de elementos que se devolverán en una sola llamada.
- nextToken: se usa para recuperar el siguiente conjunto de resultados (mostraremos de dónde proviene el valor de nextToken más adelante).
Guarde los cambios realizados en el solucionador.

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

Llama al API para escanear todas las publicaciones

Ahora que el solucionador está configurado, AWS AppSync sabe cómo convertir una allPost consulta entrante en una operación de Amazon Scan DynamoDB. Ahora puede recorrer la tabla para obtener todas las publicaciones. Sin embargo, antes de probarlo, debe rellenar la tabla datos, ya que hemos eliminado las publicaciones con las que hemos estado trabajado hasta ahora.

Para añadir y consultar datos

En la suyaAPI, seleccione la pestaña Consultas.

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


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

Seleccione Ejecutar (el botón de reproducción naranja).
Ahora recorreremos la tabla obteniendo cinco resultados cada vez. En el panel Consultas, añada la siguiente consulta:
```
query allPost {
  allPost(limit: 5) {
    posts {
      id
      title
    }
    nextToken
  }
}
```

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija allPost.

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


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

Ha recibido cinco resultados y un nextToken, que permite obtener el siguiente conjunto de resultados. Actualice la consulta allPost para incluir el valor de nextToken del conjunto de resultados anterior:
```
query allPost {
  allPost(
    limit: 5
    nextToken: "<token>"
  ) {
    posts {
      id
      author
    }
    nextToken
  }
}
```

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija allPost.

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


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

Configuración de una resolución de allPostsBy autor (Amazon DynamoDB Query)

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

Para añadir su consulta

En la suyaAPI, elija la pestaña Esquema.
En el panel Schema (Esquema) modifique el tipo Query para agregar una nueva consulta allPostsByAuthor, de este modo:
```
type Query {
    allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
    allPost(limit: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}
```
Tenga en cuenta que aquí vuelve a usarse el tipo PaginatedPosts que empleamos con la consulta allPost.
Elija Save Schema (Guardar esquema).
En el panel Solucionadores de la derecha, busque el campo allPostsByAuthor recién creado en el tipo Query y, a continuación, seleccione Asociar. Cree un solucionador con el siguiente fragmento:
```
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const { limit = 20, nextToken, author } = ctx.arguments;
  return ddb.query({
    index: 'author-index',
    query: { author: { eq: author } },
    limit,
    nextToken,
  });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}
```
Al igual que el solucionador allPost, este solucionador tiene dos argumentos opcionales:
- limit: especifica el número máximo de elementos que se devolverán en una sola llamada.
- nextToken: recupera el siguiente conjunto de resultados (el valor de nextToken puede obtenerse de una llamada anterior).
Guarde los cambios realizados en el solucionador.

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

Llama al API para consultar todas las publicaciones por autor

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

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

Para añadir datos y consultas

En la suyaAPI, seleccione la pestaña Consultas.

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


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija addPost.
Ahora consultaremos la tabla para que devuelva todas las publicaciones creadas por Nadia. En el panel Consultas, añada la siguiente consulta:
```
query allPostsByAuthor {
  allPostsByAuthor(author: "Nadia") {
    posts {
      id
      title
    }
    nextToken
  }
}
```

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija allPostsByAuthor. Todas las publicaciones creadas por Nadia deben aparecer en el panel Resultados a la derecha del panel Consultas. Debería parecerse a lo que sigue:


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

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

En el panel Consultas, añada la siguiente consulta:


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija allPostsByAuthor. Todas las publicaciones creadas por AUTHORNAME deben aparecer en el panel Resultados a la derecha del panel Consultas. Debería parecerse a lo que sigue:


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

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


query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    limit: 5
    nextToken: "<token>"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija allPostsByAuthor. Las demás publicaciones creadas por AUTHORNAME deben aparecer en el panel Resultados a la derecha del panel Consultas. Debería parecerse a lo que sigue:


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

Uso de conjuntos

Hasta ahora, el tipo Post era un objeto clave/valor plano. El solucionador también permite modelar objetos complejos, como conjuntos, listas y mapas. Vamos a actualizar el tipo Post para incluir etiquetas. Una publicación puede tener cero o más etiquetas, que se almacenan en DynamoDB como un conjunto de cadenas. También configuraremos algunas mutaciones para añadir y eliminar etiquetas, y una nueva consulta para buscar las publicaciones con una etiqueta concreta.

Para configurar sus datos

En la suyaAPI, elija la pestaña Esquema.

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


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

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


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

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


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

Elija Save Schema (Guardar esquema).

En el panel Solucionadores de la derecha, busque el campo allPostsByTag recién creado en el tipo Query y, a continuación, seleccione Asociar. Cree su solucionador con el siguiente fragmento:


import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const { limit = 20, nextToken, tag } = ctx.arguments;
  return ddb.scan({ limit, nextToken, filter: { tags: { contains: tag } } });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}

Guarde los cambios que haya realizado en el solucionador.

Ahora, haga lo mismo con el campo addTag de Mutation usando el siguiente fragmento:

nota

Aunque las utilidades de DynamoDB actualmente no admiten operaciones de conjuntos, puede interactuar con los conjuntos creando la solicitud usted mismo.


import { util } from '@aws-appsync/utils'

export function request(ctx) {
	const { id, tag } = ctx.arguments
	const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 })
	expressionValues[':tags'] = util.dynamodb.toStringSet([tag])

	return {
		operation: 'UpdateItem',
		key: util.dynamodb.toMapValues({ id }),
		update: {
			expression: `ADD tags :tags, version :plusOne`,
			expressionValues,
		},
	}
}

export const response = (ctx) => ctx.result

Guarde los cambios realizados en el solucionador.

Repita esta operación una vez más para el campo removeTag de Mutation utilizando el siguiente fragmento:


import { util } from '@aws-appsync/utils';
	
export function request(ctx) {
	  const { id, tag } = ctx.arguments;
	  const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 });
	  expressionValues[':tags'] = util.dynamodb.toStringSet([tag]);
	
	  return {
	    operation: 'UpdateItem',
	    key: util.dynamodb.toMapValues({ id }),
	    update: {
	      expression: `DELETE tags :tags ADD version :plusOne`,
	      expressionValues,
	    },
	  };
	}
	
	export const response = (ctx) => ctx.resultexport

Guarde los cambios realizados en el solucionador.

APILlámalos para trabajar con etiquetas

Ahora que ha configurado los resolutores, AWS AppSync sabe cómo traducir las solicitudes entrantes addTag y las allPostsByTag solicitudes a UpdateItem DynamoDB Scan y a las operaciones. removeTag Para probarlo, vamos a seleccionar una de las publicaciones que ha creado anteriormente. Por ejemplo, tomemos una publicación creada por Nadia.

Para usar etiquetas

En la suyaAPI, seleccione la pestaña Consultas.

En el panel Consultas, añada la siguiente consulta:


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija allPostsByAuthor.

Todas las publicaciones de Nadia deben aparecer en el panel Resultados a la derecha del panel Consultas. Debería parecerse a lo que sigue:


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

Usemos el que tiene el título The cutest dog in the world. Registre su id, ya que vamos a utilizarlo más adelante. Ahora probemos a añadirle la etiqueta dog.
En el panel Consultas, pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente.
```
mutation addTag {
  addTag(id:10 tag: "dog") {
    id
    title
    tags
  }
}
```

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija addTag. La publicación se actualiza con la nueva etiqueta:


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

Puede añadir más etiquetas. Actualice la mutación para cambiar el argumento tag a puppy:


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija addTag. La publicación se actualiza con la nueva etiqueta:


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

También puede eliminar etiquetas. En el panel Consultas, pegue la mutación siguiente. También tendrá que actualizar el argumento id con el valor que anotó anteriormente:
```
mutation removeTag {
  removeTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}
```

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija removeTag. La publicación se actualiza y la etiqueta puppy se elimina.


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

También puede buscar todas las publicaciones que tengan una etiqueta. En el panel Consultas, añada la siguiente consulta:


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

Seleccione Ejecutar (el botón de reproducción naranja) y, a continuación, elija allPostsByTag. Se devolverán todas las publicaciones que tenga la etiqueta dog, de este modo:


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

Conclusión

En este tutorial, ha creado una API que le permite manipular Post objetos en DynamoDB mediante GraphQL AWS AppSync .

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

Para eliminar el rol asociado a la tabla de DynamoDB, seleccione el origen de datos en la tabla Orígenes de datos y haga clic en Editar. Anote el valor del rol en Crear o usar un rol existente. Ve a la IAM consola para eliminar el rol.

Para eliminar la tabla de DynamoDB, haga clic en el nombre de la tabla en la lista de orígenes de datos. Esto le llevará a la consola de DynamoDB, donde podrá eliminar la tabla.

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

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

Convenciones del documento

JavaScript tutoriales de resolución

Uso de resolutores AWS Lambda