As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# AWS AppSync JavaScript referência de objeto de contexto do resolvedor
<a name="resolver-context-reference-js"></a>

AWS AppSync define um conjunto de variáveis e funções para trabalhar com manipuladores de solicitações e respostas. Isso facilita as operações lógicas em dados com o GraphQL. Este documento descreve essas funções e fornece exemplos.

## Acesso ao `context`
<a name="accessing-the-context-js"></a>

O argumento `context` de um manipulador de solicitações e respostas é um objeto que contém todas as informações contextuais para a invocação do seu resolvedor. Ela tem a seguinte estrutura:

```
type Context = {
  arguments: any;
  args: any;
  identity: Identity;
  source: any;
  error?: {
    message: string;
    type: string;
  };
  stash: any;
  result: any;
  prev: any;
  request: Request;
  info: Info;
};
```

**nota**  
Você descobrirá que o objeto `context` é chamado de `ctx`.

Cada campo no objeto `context` é definido da seguinte forma:

### Campos de `context`
<a name="accessing-the-context-list-js"></a>

** `arguments` **  
Um mapa que contém todos os argumentos do GraphQL para este campo.

** `identity` **  
Um objeto que contém informações sobre o chamador. Para obter mais informações sobre a estrutura desse campo, consulte [Identidade](#aws-appsync-resolver-context-reference-identity-js).

** `source` **  
Um mapa que contém a resolução do campo pai.

** `stash` **  
O stash é um objeto disponibilizado dentro de cada manipulador de resolvedor e função. O mesmo objeto stash subsiste por meio de uma única execução de resolvedor. Isso significa que é possível usar o stash para passar dados arbitrários entre os manipuladores de solicitações e respostas e entre as funções em um resolvedor de pipeline.   
Não é possível excluir ou substituir o stash inteiro, mas você pode adicionar, atualizar, excluir e ler as propriedades dele. 
Você pode adicionar itens ao stash modificando um dos exemplos de código abaixo:  

```
//Example 1
ctx.stash.newItem = { key: "something" }

//Example 2
Object.assign(ctx.stash, {key1: value1, key2: value})
```
Você pode remover itens do stash modificando o código abaixo:  

```
delete ctx.stash.key
```

** `result` **  
Um contêiner para os resultados desse resolvedor. Esse campo só está disponível para manipuladores de respostas.  
Por exemplo, se estiver resolvendo o campo `author` da seguinte consulta:  

```
query {
    getPost(id: 1234) {
        postId
        title
        content
        author {
            id
            name
        }
    }
}
```
Então, a variável `context` completa estará disponível quando um manipulador de respostas for avaliado:  

```
{
  "arguments" : {
    id: "1234"
  },
  "source": {},
  "result" : {
      "postId": "1234",
      "title": "Some title",
      "content": "Some content",
      "author": {
        "id": "5678",
        "name": "Author Name"
      }
  },
  "identity" : {
      "sourceIp" : ["x.x.x.x"],
      "userArn" : "arn:aws:iam::123456789012:user/appsync",
      "accountId" : "666666666666",
      "user" : "AIDAAAAAAAAAAAAAAAAAA"
  }
}
```

** `prev.result` **  
O resultado de qualquer operação anterior executada em um resolvedor de pipeline.  
Se a operação anterior foi o manipulador de solicitações do resolvedor de pipeline, `ctx.prev.result` representa o resultado da avaliação e será disponibilizado para a primeira função no pipeline.  
Se a operação anterior foi a primeira função, `ctx.prev.result` representa o resultado da avaliação do manipulador de respostas da primeira função e será disponibilizado para a segunda função no pipeline.  
Se a operação anterior foi a última função, `ctx.prev.result` representa o resultado da avaliação da última função e será disponibilizado para o manipulador de respostas do resolvedor do pipeline.

** `info` **  
Um objeto que contém informações sobre a solicitação do GraphQL. Para ver a estrutura desse campo, consulte [Informações](#aws-appsync-resolver-context-reference-info-js).

### Identidade
<a name="aws-appsync-resolver-context-reference-identity-js"></a>

A seção `identity` contém informações sobre o chamador. O formato dessa seção depende do tipo de autorização da sua AWS AppSync API.

Para obter mais informações sobre as opções de AWS AppSync segurança, consulte [Autorização e autenticação](security-authz.md#aws-appsync-security).

** `API_KEY` authorization**  
O campo `identity` não está preenchido.

**`AWS_LAMBDA` authorization**  
O `identity` tem o seguinte formato:  

```
type AppSyncIdentityLambda = {
  resolverContext: any;
};
```
`identity` inclui a chave `resolverContext` que tem o mesmo conteúdo de `resolverContext` retornado pela função do Lambda que autorizou a solicitação.

** `AWS_IAM` authorization**  
O `identity` tem o seguinte formato:  

```
type AppSyncIdentityIAM = {
  accountId: string;
  cognitoIdentityPoolId: string;
  cognitoIdentityId: string;
  sourceIp: string[];
  username: string;
  userArn: string;
  cognitoIdentityAuthType: string;
  cognitoIdentityAuthProvider: string;
};
```

** `AMAZON_COGNITO_USER_POOLS` authorization**  
O `identity` tem o seguinte formato:  

```
type AppSyncIdentityCognito = {
  sourceIp: string[];
  username: string;
  groups: string[] | null;
  sub: string;
  issuer: string;
  claims: any;
  defaultAuthStrategy: string;
};
```

Cada campo é definido da seguinte forma:

** `accountId` **  
O ID da AWS conta do chamador.

** `claims` **  
As reivindicações do usuário.

** `cognitoIdentityAuthType` **  
Autenticado ou não autenticado com base no tipo de identidade.

** `cognitoIdentityAuthProvider` **  
Uma lista separada por vírgulas das informações do provedor de identidade externo usada na obtenção das credenciais usadas para assinar a solicitação.

** `cognitoIdentityId` **  
O ID de identidade do Amazon Cognito do chamador.

** `cognitoIdentityPoolId` **  
O ID do banco de identidades do Amazon Cognito associado ao chamador.

** `defaultAuthStrategy` **  
A estratégia de autorização padrão para este chamador (`ALLOW` ou `DENY`).

** `issuer` **  
O emissor do token.

** `sourceIp` **  
O endereço IP de origem do chamador que AWS AppSync recebe. Se a solicitação não incluir o cabeçalho `x-forwarded-for`, o valor do IP de origem conterá apenas um único endereço IP da conexão TCP. Se a solicitação inclui um cabeçalho `x-forwarded-for`, o IP de origem será uma lista de endereços IP do cabeçalho `x-forwarded-for`, além do endereço IP da conexão TCP.

** `sub` **  
O UUID do usuário autenticado.

** `user` **  
O usuário do IAM.

** `userArn` **  
O nome do recurso da Amazon (ARN) do usuário do IAM.

** `username` **  
O nome do usuário autenticado. Em caso de autorização `AMAZON_COGNITO_USER_POOLS`, o valor do nome de usuário é o valor de *username* é o valor do atributo *cognito:username*. No caso de `AWS_IAM` autorização, o valor do *nome de usuário* é o valor do AWS usuário principal. Se você estiver usando a autorização do IAM com credenciais fornecidas por bancos de identidades do Amazon Cognito, recomendamos utilizar `cognitoIdentityId`.

### Cabeçalhos de solicitação de acesso
<a name="aws-appsync-resolver-context-reference-util-js"></a>

AWS AppSync suporta passar cabeçalhos personalizados de clientes e acessá-los em seus resolvedores GraphQL usando. `ctx.request.headers` Em seguida, você pode usar valores de cabeçalho para ações como inserir dados em uma fonte de dados ou até mesmo verificações de autorização. É possível utilizar cabeçalhos de solicitação por meio de `$curl` com uma chave da API na linha de comando conforme mostrado nos exemplos a seguir:

**Exemplo de cabeçalho único** 

Digamos que você defina um cabeçalho `custom` com um valor de `nadia` da seguinte forma:

```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:nadia" -H "x-api-key:<API-KEY-VALUE>" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https://<ENDPOINT>/graphql
```

Isso pode ser acessado com `ctx.request.headers.custom`. Por exemplo, ele pode estar no seguinte código para o DynamoDB:

```
"custom": util.dynamodb.toDynamoDB(ctx.request.headers.custom)
```

**Exemplo de vários cabeçalhos** 

Você também pode enviar vários cabeçalhos em uma única solicitação e acessá-los no manipulador do resolvedor. Por exemplo, se o cabeçalho `custom` foi definido com dois valores:

```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:bailey" -H "custom:nadia" -H "x-api-key:<API-KEY-VALUE>" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https://<ENDPOINT>/graphql
```

Em seguida, você pode acessá-los como uma matriz, como `ctx.request.headers.custom[1]`.

**nota**  
AWS AppSync não expõe o cabeçalho do cookie em`ctx.request.headers`.

### Acessar o nome de domínio personalizado da solicitação
<a name="aws-access-requested-custom-domain-names-js"></a>

AWS AppSync suporta a configuração de um domínio personalizado que você pode usar para acessar seu GraphQL e endpoints em tempo real para seu. APIs Ao fazer uma solicitação com um nome de domínio personalizado, você pode obter o nome de domínio usando `ctx.request.domainName`.

Ao usar o nome de domínio padrão do endpoint do GraphQL, o valor será `null`.

### Informações
<a name="aws-appsync-resolver-context-reference-info-js"></a>

A seção `info` contém informações sobre a solicitação do GraphQL. Esta seção tem o seguinte formato:

```
type Info = {
  fieldName: string;
  parentTypeName: string;
  variables: any;
  selectionSetList: string[];
  selectionSetGraphQL: string;
};
```

Cada campo é definido da seguinte forma:

** `fieldName` **  
O nome do campo que está sendo resolvido no momento.

** `parentTypeName` **  
O nome do tipo pai para o campo que está sendo resolvido no momento.

** `variables` **  
Um mapa que contém todas as variáveis que são passadas para a solicitação do GraphQL.

** `selectionSetList` **  
Uma representação de lista dos campos no conjunto de seleções do GraphQL. Os campos com alias serão referenciados somente pelo nome do alias, não pelo nome do campo. O exemplo a seguir mostra isso em detalhes.

** `selectionSetGraphQL` **  
Uma representação de string do conjunto de seleções, formatada como linguagem de definição de esquema (SDL) do GraphQL. Embora os fragmentos não sejam mesclados no conjunto de seleções, os fragmentos inline são preservados, conforme mostrado no exemplo a seguir.

**nota**  
`JSON.stringify` não incluirá `selectionSetGraphQL` e `selectionSetList` na serialização da string. Você deve referenciar essas propriedades diretamente.

Por exemplo, se estiver resolvendo o campo `getPost` da seguinte consulta:

```
query {
  getPost(id: $postId) {
    postId
    title
    secondTitle: title
    content
    author(id: $authorId) {
      authorId
      name
    }
    secondAuthor(id: "789") {
      authorId
    }
    ... on Post {
      inlineFrag: comments: {
        id
      }
    }
    ... postFrag
  }
}

fragment postFrag on Post {
  postFrag: comments: {
    id
  }
}
```

Depois, a variável `ctx.info` completa que está disponível ao processar o manipulador pode ser:

```
{
  "fieldName": "getPost",
  "parentTypeName": "Query",
  "variables": {
    "postId": "123",
    "authorId": "456"
  },
  "selectionSetList": [
    "postId",
    "title",
    "secondTitle"
    "content",
    "author",
    "author/authorId",
    "author/name",
    "secondAuthor",
    "secondAuthor/authorId",
    "inlineFragComments",
    "inlineFragComments/id",
    "postFragComments",
    "postFragComments/id"
  ],
  "selectionSetGraphQL": "{\n  getPost(id: $postId) {\n    postId\n    title\n    secondTitle: title\n    content\n    author(id: $authorId) {\n      authorId\n      name\n    }\n    secondAuthor(id: \"789\") {\n      authorId\n    }\n    ... on Post {\n      inlineFrag: comments {\n        id\n      }\n    }\n    ... postFrag\n  }\n}"
}
```

`selectionSetList` expõe somente campos que pertencem ao tipo atual. Se o tipo atual for uma interface ou união, somente os campos selecionados que pertencem à interface serão expostos. Por exemplo, considerando o seguinte esquema:

```
type Query {
    node(id: ID!): Node
}

interface Node {
    id: ID
}

type Post implements Node {
    id: ID
    title: String
    author: String
}

type Blog implements Node {
    id: ID
    title: String
    category: String
}
```

E a seguinte consulta:

```
query {
    node(id: "post1") {
        id
        ... on Post {
            title
        }

        ... on Blog {
            title
        }
    }
}
```

Ao chamar `ctx.info.selectionSetList` na resolução do campo `Query.node`, somente `id` é exposto:

```
"selectionSetList": [
    "id"
]
```