Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS AppSync JavaScript Resolver-Kontext-Objektreferenz
<a name="resolver-context-reference-js"></a>

AWS AppSync definiert eine Reihe von Variablen und Funktionen für die Arbeit mit Anfrage- und Antworthandlern. Dies erleichtert logische Operationen an Daten mit GraphQL. Dieses Dokument beschreibt diese Funktionen und enthält Beispiele.

## Zugreifen auf den `context`
<a name="accessing-the-context-js"></a>

Das `context` Argument eines Request- und Response-Handlers ist ein Objekt, das alle Kontextinformationen für Ihren Resolver-Aufruf enthält. Sie hat die folgende Struktur:

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

**Anmerkung**  
Sie werden häufig feststellen, dass das `context` Objekt als bezeichnet wird. `ctx`

Jedes Feld im `context` Objekt ist wie folgt definiert:

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

** `arguments` **  
Eine Zuordnung, die alle GraphQL-Argumente für dieses Feld enthält.

** `identity` **  
Ein Objekt, das Informationen über den Aufrufer enthält. Weitere Informationen zur Struktur dieses Felds finden Sie unter [Identity](#aws-appsync-resolver-context-reference-identity-js).

** `source` **  
Eine Zuordnung, die die Auflösung des übergeordneten Feldes enthält.

** `stash` **  
Der Stash ist ein Objekt, das in jedem Resolver und Funktionshandler verfügbar gemacht wird. Das gleiche Stash-Objekt durchläuft einen einzigen Resolver-Lauf. Das bedeutet, dass Sie den Stash verwenden können, um beliebige Daten zwischen Anfrage- und Antworthandlern und zwischen Funktionen in einem Pipeline-Resolver zu übergeben.   
Sie können nicht den gesamten Stash löschen oder ersetzen, aber Sie können Eigenschaften des Stashs hinzufügen, aktualisieren, löschen und lesen. 
Sie können dem Stash Elemente hinzufügen, indem Sie eines der folgenden Codebeispiele ändern:  

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

//Example 2
Object.assign(ctx.stash, {key1: value1, key2: value})
```
Sie können Artikel aus dem Stash entfernen, indem Sie den folgenden Code ändern:  

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

** `result` **  
Ein Container für die Ergebnisse dieses Resolvers. Dieses Feld ist nur für Antworthandler verfügbar.  
Zum Beispiel, wenn Sie das `author` Feld der folgenden Abfrage auflösen:  

```
query {
    getPost(id: 1234) {
        postId
        title
        content
        author {
            id
            name
        }
    }
}
```
Dann ist die vollständige `context` Variable verfügbar, wenn ein Antworthandler ausgewertet wird:  

```
{
  "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` **  
Das Ergebnis einer beliebigen vorherigen Operation, die in einem Pipeline-Resolver ausgeführt wurde.  
Wenn der vorherige Vorgang der Anforderungshandler des Pipeline-Resolvers war, `ctx.prev.result` stellt er dieses Auswertungsergebnis dar und wird der ersten Funktion in der Pipeline zur Verfügung gestellt.  
Wenn die vorherige Operation die erste Funktion war, `ctx.prev.result` stellt sie das Auswertungsergebnis des Antworthandlers der ersten Funktion dar und wird der zweiten Funktion in der Pipeline zur Verfügung gestellt.  
Wenn die vorherige Operation die letzte Funktion war, `ctx.prev.result` stellt sie das Auswertungsergebnis der letzten Funktion dar und wird dem Response-Handler des Pipeline-Resolvers zur Verfügung gestellt.

** `info` **  
Ein Objekt, das Informationen über die GraphQL-Anforderung enthält. Die Struktur dieses Feldes finden Sie unter [Info](#aws-appsync-resolver-context-reference-info-js).

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

Der Abschnitt `identity` enthält Informationen über den Aufrufer. Die Form dieses Abschnitts hängt vom Autorisierungstyp Ihrer AWS AppSync API ab.

Weitere Informationen zu AWS AppSync Sicherheitsoptionen finden Sie unter [Autorisierung und Authentifizierung](security-authz.md#aws-appsync-security).

** `API_KEY`-Autorisierung**  
Das `identity` Feld ist nicht gefüllt.

**`AWS_LAMBDA`-Autorisierung**  
Das `identity` hat die folgende Form:  

```
type AppSyncIdentityLambda = {
  resolverContext: any;
};
```
Der `identity` enthält den `resolverContext` Schlüssel, der denselben `resolverContext` Inhalt enthält, der von der Lambda-Funktion zurückgegeben wurde, die die Anfrage autorisiert.

** `AWS_IAM`-Autorisierung**  
Der `identity` hat die folgende Form:  

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

** `AMAZON_COGNITO_USER_POOLS`-Autorisierung**  
Der `identity` hat die folgende Form:  

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

Jedes Feld ist wie folgt definiert:

** `accountId` **  
Die AWS Konto-ID des Anrufers.

** `claims` **  
Die Ansprüche, die der Benutzer hat.

** `cognitoIdentityAuthType` **  
Entweder authentifiziert oder nicht authentifiziert, basierend auf dem Identitätstyp.

** `cognitoIdentityAuthProvider` **  
Eine durch Kommas getrennte Liste mit Informationen zu externen Identitätsanbietern, anhand derer die Anmeldeinformationen abgerufen wurden, mit denen die Anfrage signiert wurde.

** `cognitoIdentityId` **  
Die Amazon Cognito Cognito-Identitäts-ID des Anrufers.

** `cognitoIdentityPoolId` **  
Die dem Anrufer zugeordnete Amazon Cognito Cognito-Identitätspool-ID.

** `defaultAuthStrategy` **  
Die Standardautorisierungsstrategie für diesen Aufrufer (`ALLOW` oder `DENY`).

** `issuer` **  
Der Aussteller des Tokens.

** `sourceIp` **  
Die Quell-IP-Adresse des Anrufers, der empfängt. AWS AppSync Wenn die Anfrage den `x-forwarded-for` Header nicht enthält, enthält der Quell-IP-Wert nur eine einzige IP-Adresse aus der TCP-Verbindung. Wenn die Anforderung einen `x-forwarded-for`-Header enthält, verfügt die Quell-IP zusätzlich zur IP-Adresse aus der TCP-Verbindung über eine Liste mit IP-Adressen aus dem `x-forwarded-for`-Header.

** `sub` **  
Die UUID des authentifizierten Benutzers.

** `user` **  
Der IAM-Benutzer.

** `userArn` **  
Der Amazon-Ressourcenname (ARN) des IAM-Benutzers.

** `username` **  
Der Benutzername des authentifizierten Benutzers. Bei einer `AMAZON_COGNITO_USER_POOLS`-Autorisierung ist der Wert des *Benutzernamens* der Wert des Attributs *cognito:username*. Im Fall einer `AWS_IAM` Autorisierung entspricht der Wert von *username* dem Wert des AWS Benutzerprinzipals. Wenn Sie die IAM-Autorisierung mit Anmeldeinformationen verwenden, die aus Amazon Cognito Cognito-Identitätspools stammen, empfehlen wir Ihnen, diese zu verwenden. `cognitoIdentityId`

### Auf Header von Anfragen zugreifen
<a name="aws-appsync-resolver-context-reference-util-js"></a>

AWS AppSync unterstützt die Übergabe benutzerdefinierter Header von Clients und den Zugriff auf sie in Ihren GraphQL-Resolvern mithilfe von. `ctx.request.headers` Sie können die Header-Werte dann für Aktionen wie das Einfügen von Daten in eine Datenquelle oder für Autorisierungsprüfungen verwenden. Sie können einzelne oder mehrere Anforderungsheader `$curl` mithilfe eines API-Schlüssels von der Befehlszeile aus verwenden, wie in den folgenden Beispielen gezeigt:

**Beispiel für einen einzelnen Header** 

Angenommen, Sie legen wie folgt einen `custom`-Header mit dem Wert `nadia` fest:

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

Darauf könnte dann mit `ctx.request.headers.custom` zugegriffen werden. Es könnte beispielsweise im folgenden Code für DynamoDB enthalten sein:

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

**Beispiel für mehrere Header** 

Sie können auch mehrere Header in einer einzigen Anfrage übergeben und im Resolver-Handler auf diese zugreifen. Zum Beispiel, wenn der `custom` Header mit zwei Werten festgelegt ist:

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

Sie können dann darauf als Array zugreifen, z. B. `ctx.request.headers.custom[1]`.

**Anmerkung**  
AWS AppSync macht den Cookie-Header in nicht verfügbar`ctx.request.headers`.

### Greifen Sie auf den angeforderten benutzerdefinierten Domainnamen zu
<a name="aws-access-requested-custom-domain-names-js"></a>

AWS AppSync unterstützt die Konfiguration einer benutzerdefinierten Domain, mit der Sie auf Ihre GraphQL- und Echtzeit-Endpunkte für Ihre zugreifen können. APIs Wenn Sie eine Anfrage mit einem benutzerdefinierten Domainnamen stellen, können Sie den Domainnamen mithilfe von abrufen. `ctx.request.domainName`

Bei Verwendung des standardmäßigen GraphQL-Endpunktdomänennamens lautet der Wert. `null`

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

Der Abschnitt `info` enthält Informationen über die GraphQL-Anforderung. Dieser Abschnitt hat die folgende Form:

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

Jedes Feld ist wie folgt definiert:

** `fieldName` **  
Der Name des Feldes, das derzeit aufgelöst wird.

** `parentTypeName` **  
Der Name des übergeordneten Typs für das Feld, das derzeit aufgelöst wird.

** `variables` **  
Eine Zuordnung, die alle Variablen enthält, die an die GraphQL-Anforderung übergeben werden.

** `selectionSetList` **  
Eine Listendarstellung der Felder im GraphQL-Auswahlsatz. Felder mit Aliasnamen werden nur durch den Aliasnamen referenziert, nicht durch den Feldnamen. Im folgenden Beispiel ist dies detailliert dargestellt.

** `selectionSetGraphQL` **  
Eine Zeichenfolgendarstellung des Auswahlsatzes, formatiert als GraphQL-Schemadefinitionssprache (SDL). Fragmente werden zwar nicht mit dem Auswahlsatz zusammengeführt, Inline-Fragmente bleiben jedoch erhalten, wie im folgenden Beispiel gezeigt.

**Anmerkung**  
`JSON.stringify`schließt `selectionSetGraphQL` und nicht `selectionSetList` in die Serialisierung der Zeichenfolge ein. Sie müssen direkt auf diese Eigenschaften verweisen.

Angenommen, Sie lösen das `getPost`-Feld der folgenden Abfrage auf:

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

Dann könnte die vollständige `ctx.info` Variable, die bei der Verarbeitung eines Handlers verfügbar ist, wie folgt lauten:

```
{
  "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`macht nur Felder verfügbar, die zum aktuellen Typ gehören. Wenn es sich bei dem aktuellen Typ um eine Schnittstelle oder Union handelt, werden nur ausgewählte Felder angezeigt, die zur Schnittstelle gehören. Nehmen wir zum Beispiel das folgende Schema:

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

Und die folgende Abfrage:

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

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

`ctx.info.selectionSetList`Beim Aufrufen mit der `Query.node` Feldauflösung `id` wird nur angezeigt:

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