Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# AWS AppSync JavaScript riferimento all'oggetto contestuale del resolver
<a name="resolver-context-reference-js"></a>

AWS AppSync definisce un insieme di variabili e funzioni per lavorare con i gestori di richieste e risposte. Ciò semplifica le operazioni logiche sui dati con GraphQL. Questo documento descrive tali funzioni e fornisce esempi.

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

L'`context`argomento di un gestore di richieste e risposte è un oggetto che contiene tutte le informazioni contestuali per la chiamata del resolver. Ha la struttura seguente:

```
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**  
Scoprirete spesso che l'`context`oggetto viene chiamato. `ctx`

Ogni campo dell'`context`oggetto è definito come segue:

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

** `arguments` **  
Una mappa contenente tutti gli argomenti GraphQL per questo campo.

** `identity` **  
Un oggetto contenente le informazioni sul chiamante. Vedi [Identità](#aws-appsync-resolver-context-reference-identity-js) per ulteriori informazioni sulla struttura di questo campo.

** `source` **  
Una mappa contenente la risoluzione del campo padre.

** `stash` **  
Lo stash è un oggetto reso disponibile all'interno di ogni resolver e gestore di funzioni. Lo stesso oggetto stash vive durante una singola esecuzione del resolver. Ciò significa che è possibile utilizzare lo stash per passare dati arbitrari tra gestori di richieste e risposte e tra funzioni in un resolver di pipeline.   
Non è possibile eliminare o sostituire l'intera scorta, ma è possibile aggiungere, aggiornare, eliminare e leggere le proprietà della scorta. 
Puoi aggiungere elementi alla scorta modificando uno degli esempi di codice seguenti:  

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

//Example 2
Object.assign(ctx.stash, {key1: value1, key2: value})
```
Puoi rimuovere elementi dalla scorta modificando il codice seguente:  

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

** `result` **  
Un container per i risultati di questo resolver. Questo campo è disponibile solo per i gestori di risposte.  
Ad esempio, se stai risolvendo il `author` campo della seguente query:  

```
query {
    getPost(id: 1234) {
        postId
        title
        content
        author {
            id
            name
        }
    }
}
```
Quindi la `context` variabile completa è disponibile quando viene valutato un gestore di risposte:  

```
{
  "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` **  
Il risultato di qualsiasi operazione precedente sia stata eseguita in un resolver di pipeline.  
Se l'operazione precedente era il gestore delle richieste del risolutore di pipeline, allora `ctx.prev.result` rappresenta il risultato della valutazione e viene reso disponibile alla prima funzione della pipeline.  
Se l'operazione precedente era la prima funzione, `ctx.prev.result` rappresenta il risultato della valutazione del gestore della risposta della prima funzione e viene reso disponibile alla seconda funzione nella pipeline.  
Se l'operazione precedente era l'ultima funzione, `ctx.prev.result` rappresenta il risultato della valutazione dell'ultima funzione e viene resa disponibile al gestore di risposte del risolutore di pipeline.

** `info` **  
Un oggetto contenente le informazioni sulla richiesta GraphQL. Per la struttura di questo campo, consulta [Info](#aws-appsync-resolver-context-reference-info-js).

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

La sezione `identity` contiene le informazioni sul chiamante. La forma di questa sezione dipende dal tipo di autorizzazione dell'API. AWS AppSync 

Per ulteriori informazioni sulle opzioni di AWS AppSync sicurezza, consulta [Autorizzazione e autenticazione](security-authz.md#aws-appsync-security).

** Autorizzazione `API_KEY`**  
Il `identity` campo non è compilato.

**Autorizzazione `AWS_LAMBDA`**  
`identity`Ha la forma seguente:  

```
type AppSyncIdentityLambda = {
  resolverContext: any;
};
```
`identity`Contiene la `resolverContext` chiave, contenente lo stesso `resolverContext` contenuto restituito dalla funzione Lambda che autorizza la richiesta.

** Autorizzazione `AWS_IAM`**  
`identity`Ha la seguente forma:  

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

** Autorizzazione `AMAZON_COGNITO_USER_POOLS`**  
`identity`Ha la forma seguente:  

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

Ogni campo è definito nel modo seguente:

** `accountId` **  
L'ID dell' AWS account del chiamante.

** `claims` **  
Le attestazioni dell'utente.

** `cognitoIdentityAuthType` **  
Autenticato o non autenticato in base al tipo di identità.

** `cognitoIdentityAuthProvider` **  
Un elenco separato da virgole di informazioni sul provider di identità esterno utilizzato per ottenere le credenziali utilizzate per firmare la richiesta.

** `cognitoIdentityId` **  
L'ID identificativo Amazon Cognito del chiamante.

** `cognitoIdentityPoolId` **  
L'ID del pool di identità di Amazon Cognito associato al chiamante.

** `defaultAuthStrategy` **  
La strategia di autorizzazione predefinita per questo chiamante (`ALLOW` o `DENY`).

** `issuer` **  
L'emittente del token.

** `sourceIp` **  
L'indirizzo IP di origine del chiamante che riceve. AWS AppSync Se la richiesta non include l'`x-forwarded-for`intestazione, il valore IP di origine contiene solo un singolo indirizzo IP dalla connessione TCP. Se la richiesta include un'intestazione `x-forwarded-for`, l'IP di origine sarà un elenco di indirizzi IP dell'intestazione `x-forwarded-for` oltre all'indirizzo IP proveniente dalla connessione TCP.

** `sub` **  
l'UUID dell'utente autenticato.

** `user` **  
L'utente IAM.

** `userArn` **  
L'Amazon Resource Name (ARN) dell'utente IAM.

** `username` **  
Il nome dell'utente autenticato. In caso di autorizzazione `AMAZON_COGNITO_USER_POOLS`, il valore del *nome utente* è il valore dell'attributo *cognito:username*. In caso di `AWS_IAM` autorizzazione, il valore del *nome utente* è il valore del principale AWS utente. Se utilizzi l'autorizzazione IAM con credenziali fornite dai pool di identità di Amazon Cognito, ti consigliamo di utilizzare. `cognitoIdentityId`

### Intestazioni delle richieste di accesso
<a name="aws-appsync-resolver-context-reference-util-js"></a>

AWS AppSync supporta il passaggio di intestazioni personalizzate dai client e l'accesso ad esse nei resolver GraphQL utilizzando. `ctx.request.headers` È quindi possibile utilizzare i valori dell'intestazione per azioni come l'inserimento di dati in una fonte di dati o i controlli di autorizzazione. È possibile utilizzare intestazioni di richiesta singole o multiple utilizzando `$curl` una chiave API dalla riga di comando, come illustrato negli esempi seguenti:

**Esempio di intestazione singola** 

Supponi di impostare un'intestazione `custom` con il valore `nadia` come segue:

```
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
```

Potrai quindi accedervi con `ctx.request.headers.custom`. Ad esempio, potrebbe essere nel codice seguente per DynamoDB:

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

**Esempio di intestazione multipla** 

Puoi anche passare più intestazioni in una singola richiesta e accedervi nel gestore del resolver. Ad esempio, se l'`custom`intestazione è impostata con due valori:

```
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
```

Potrai quindi accedervi come matrice, ad esempio `ctx.request.headers.custom[1]`.

**Nota**  
AWS AppSync non espone l'intestazione del cookie in. `ctx.request.headers`

### Accedi al nome di dominio personalizzato della richiesta
<a name="aws-access-requested-custom-domain-names-js"></a>

AWS AppSync supporta la configurazione di un dominio personalizzato che puoi utilizzare per accedere ai tuoi endpoint GraphQL e in tempo reale per il tuo. APIs Quando si effettua una richiesta con un nome di dominio personalizzato, è possibile ottenere il nome di dominio utilizzando. `ctx.request.domainName`

Quando si utilizza il nome di dominio endpoint GraphQL predefinito, il valore è. `null`

### Informazioni
<a name="aws-appsync-resolver-context-reference-info-js"></a>

La sezione `info` contiene informazioni sulla richiesta GraphQL. Questa sezione ha il seguente formato:

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

Ogni campo è definito nel modo seguente:

** `fieldName` **  
Il nome del campo attualmente in corso di risoluzione.

** `parentTypeName` **  
Il nome del tipo padre per il campo attualmente in corso di risoluzione.

** `variables` **  
Una mappa contenente tutte le variabili che vengono passate nella richiesta GraphQL.

** `selectionSetList` **  
Rappresentazione elenco dei campi nel set di selezione GraphQL. I campi con alias sono referenziati solo dal nome dell'alias, non dal nome del campo. L'esempio seguente mostra questa indicazione in dettaglio.

** `selectionSetGraphQL` **  
Rappresentazione stringa del set di selezione, formattata come SDL (Schema Definition Language) GraphQL. Sebbene i frammenti non vengano uniti nel set di selezione, i frammenti in linea vengono conservati, come illustrato nell'esempio seguente.

**Nota**  
`JSON.stringify`non includerà `selectionSetGraphQL` e `selectionSetList` nella serializzazione delle stringhe. È necessario fare riferimento direttamente a queste proprietà.

Ad esempio, se stai risolvendo il campo `getPost` della query seguente:

```
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
  }
}
```

Quindi la `ctx.info` variabile completa disponibile durante l'elaborazione di un gestore potrebbe essere:

```
{
  "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`espone solo i campi che appartengono al tipo corrente. Se il tipo corrente è un'interfaccia o un'unione, vengono esposti solo i campi selezionati che appartengono all'interfaccia. Ad esempio, dato lo schema seguente:

```
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 la seguente domanda:

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

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

Quando si chiama `ctx.info.selectionSetList` alla risoluzione del `Query.node` campo, `id` viene esposto solo:

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