Combinação de resolvedores do GraphQL no AWS AppSync

Os resolvedores e campos em um esquema do GraphQL têm relacionamentos 1:1 com um grande grau de flexibilidade. Como uma fonte de dados é configurada em um resolvedor independentemente de um esquema, você tem a capacidade de resolver ou manipular seus tipos do GraphQL por meio de diferentes fontes de dados, permitindo misturar e combinar um esquema para melhor atender às suas necessidades.

Os cenários a seguir demonstram como misturar e combinar fontes de dados no seu esquema. Antes de começar, você deve estar familiarizado com a configuração de fontes de dados e resolvedores para AWS Lambda, Amazon DynamoDB e Amazon OpenSearch Service.

Esquema de exemplo

O esquema a seguir tem um tipo de Post com três Query e operações Mutation cada:

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

type Query {
    allPost: [Post]
    getPost(id: ID!): Post
    searchPosts: [Post]
}

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

Neste exemplo, você teria um total de seis resolvedores, cada um precisando de uma fonte de dados. Uma forma de resolver esse problema seria conectá-los a uma única tabela do Amazon DynamoDB, chamada Posts, na qual o campo AllPost executa uma verificação e o campo searchPosts executa uma consulta (consulte Referência da função do resolvedor de JavaScript para o DynamoDB). No entanto, você não está limitado ao Amazon DynamoDB; existem diferentes fontes de dados, como Lambda ou OpenSearch Service, para atender aos seus requisitos de negócios.

Alteração de dados por meio de resolvedores

Talvez seja necessário retornar resultados de um banco de dados de terceiros que não seja diretamente compatível com fontes de dados do AWS AppSync. Talvez você também precise realizar modificações complexas nos dados antes que eles sejam retornados aos clientes da API. Isso pode ser causado pela formatação inadequada dos tipos de dados, como diferenças de carimbo de data/hora nos clientes ou pelo tratamento de problemas de compatibilidade com versões anteriores. Nesse caso, conectar funções AWS Lambda como fonte de dados à sua API AWS AppSync é a solução adequada. Para fins ilustrativos, no exemplo a seguir, uma função AWS Lambda manipula dados obtidos de um armazenamento de dados de terceiros:

export const handler = (event, context, callback) => {
    // fetch data
    const result = fetcher()

    // apply complex business logic
    const data = transform(result)	

    // return to AppSync
    return data
};

Essa é uma função do Lambda perfeitamente válida e pode ser anexada ao campo AllPost no esquema do GraphQL para que qualquer consulta que retorne todos os resultados obtenha números aleatórios para os votos positivos/negativos.

DynamoDB e OpenSearch Service

Para alguns aplicativos, você pode executar mutações ou consultas de pesquisa simples no DynamoDB e ter um processo em segundo plano para transferir documentos ao OpenSearch Service. Basta anexar o resolvedor searchPosts à fonte de dados do OpenSearch Service e retornar os resultados de pesquisa (a partir dos dados originados no DynamoDB) usando uma consulta do GraphQL. Isso pode ser extremamente poderoso ao adicionar operações de pesquisa avançadas aos aplicativos, como palavra-chave, correspondências de palavras confusas ou até mesmo pesquisas geoespaciais. A transferência de dados do DynamoDB pode ser feita por meio de um processo ETL ou, como alternativa, você pode transmitir do DynamoDB usando o Lambda.

Para começar a usar essas fontes de dados específicas, consulte nossos tutoriais do DynamoDB e Lambda.

Por exemplo, usando o esquema do nosso tutorial anterior, a seguinte mutação adiciona um item ao DynamoDB:

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

Isso grava dados no DynamoDB, que então transmite dados por meio do Lambda para o Amazon OpenSearch Service, que você usa para pesquisar publicações em campos diferentes. Por exemplo, como os dados estão no Amazon OpenSearch Service, você pode pesquisar os campos autor ou conteúdo com texto livre, mesmo com espaços, da seguinte forma:

query searchName{
    searchAuthor(name:"   Nadia   "){
        id
        title
        content
    }
}

---------- or ----------

query searchContent{
    searchContent(text:"test"){
        id
        title
        content
    }
}

Como os dados são gravados diretamente no DynamoDB, você ainda pode realizar operações de pesquisa de item ou lista eficientes na tabela com as consultas allPost{...} e getPost{...}. Essa pilha usa o seguinte código de exemplo para transmissões do DynamoDB:

import boto3
import requests
from requests_aws4auth import AWS4Auth

region = '' # e.g. us-east-1
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)

host = '' # the OpenSearch Service domain, e.g. https://search-mydomain.us-west-1.es.amazonaws.com
index = 'lambda-index'
datatype = '_doc'
url = host + '/' + index + '/' + datatype + '/'

headers = { "Content-Type": "application/json" }

def handler(event, context):
    count = 0
    for record in event['Records']:
        # Get the primary key for use as the OpenSearch ID
        id = record['dynamodb']['Keys']['id']['S']

        if record['eventName'] == 'REMOVE':
            r = requests.delete(url + id, auth=awsauth)
        else:
            document = record['dynamodb']['NewImage']
            r = requests.put(url + id, auth=awsauth, json=document, headers=headers)
        count += 1
    return str(count) + ' records processed.'

Depois, é possível usar fluxos do DynamoDB para anexá-lo a uma tabela do DynamoDB com uma chave primária de id, e quaisquer alterações na origem do DynamoDB seriam transmitidas para o seu domínio do OpenSearch Service. Para obter mais informações sobre como configurar isso, consulte a documentação de Transmissões do DynamoDB.