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. # Erweiterungen **Anmerkung** Wir unterstützen jetzt hauptsächlich die APPSYNC\$1JS-Laufzeit und ihre Dokumentation. [Bitte erwägen Sie, die APPSYNC\$1JS-Laufzeit und ihre Anleitungen hier zu verwenden.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) `$extensions`enthält eine Reihe von Methoden, mit denen Sie zusätzliche Aktionen in Ihren Resolvern ausführen können. ## Erweiterungen zwischenspeichern **`$extensions.evictFromApiCache(String, String, Object) : Object`** Löscht ein Element aus dem serverseitigen AWS AppSync Cache. Das erste Argument ist der Typname. Das zweite Argument ist der Feldname. Das dritte Argument ist ein Objekt, das Schlüssel-Wert-Paar-Elemente enthält, die den Zwischenspeicher-Schlüsselwert angeben. Sie müssen die Elemente im Objekt in derselben Reihenfolge platzieren wie die Caching-Schlüssel in den zwischengespeicherten Resolvern. `cachingKey` Dieses Tool funktioniert nur für Mutationen, nicht für Abfragen. ## Abonnementerweiterungen **`$extensions.setSubscriptionFilter(filterJsonObject)`** Definiert erweiterte Abonnementfilter. Jedes Abonnementbenachrichtigungsereignis wird anhand der bereitgestellten Abonnementfilter bewertet und sendet Benachrichtigungen an Kunden, wenn alle Filter als erfüllt gelten`true`. Das Argument wird `filterJsonObject` im folgenden Abschnitt beschrieben. Sie können diese Erweiterungsmethode nur in den Antwortzuordnungsvorlagen eines Abonnement-Resolvers verwenden. **`$extensions.setSubscriptionInvalidationFilter(filterJsonObject)`** Definiert Filter für die Invalidierung von Abonnements. Abonnementfilter werden anhand der Payload für die Invalidierung bewertet und machen dann ein bestimmtes Abonnement ungültig, wenn die Filter Folgendes ergeben. `true` Das Argument wird im `filterJsonObject` folgenden Abschnitt beschrieben. Sie können diese Erweiterungsmethode nur in den Antwortzuordnungsvorlagen eines Abonnement-Resolvers verwenden. **`$extensions.invalidateSubscriptions(invalidationJsonObject)`** Wird verwendet, um die Invalidierung eines Abonnements aufgrund einer Mutation einzuleiten. Das Argument wird `invalidationJsonObject` im folgenden Abschnitt beschrieben. Diese Erweiterung kann nur in den Response-Mapping-Vorlagen der Mutationsresolver verwendet werden. Sie können in einer einzelnen Anfrage nur maximal fünf eindeutige `$extensions.invalidateSubscriptions()` Methodenaufrufen verwenden. Wenn Sie dieses Limit überschreiten, erhalten Sie einen GraphQL-Fehler. ## Argument: filterJsonObject Das JSON-Objekt definiert entweder Abonnement- oder Invalidierungsfilter. Es ist eine Reihe von Filtern in einem`filterGroup`. Jeder Filter ist eine Sammlung einzelner Filter. ``` { "filterGroup": [ { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 } ] }, { "filters" : [ { "fieldName" : "group", "operator" : "in", "value" : ["Admin", "Developer"] } ] } ] } ``` Jeder Filter hat drei Attribute: + `fieldName`— Das GraphQL-Schemafeld. + `operator`— Der Operatortyp. + `value`— Die Werte, die mit dem `fieldName` Wert der Abonnementbenachrichtigung verglichen werden sollen. Im Folgenden finden Sie ein Beispiel für die Zuweisung dieser Attribute: ``` { "fieldName" : "severity", "operator" : "le", "value" : $context.result.severity } ``` ### Feld: fieldName Der String-Typ `fieldName` bezieht sich auf ein im GraphQL-Schema definiertes Feld, das mit der Payload `fieldName` in der Abonnementbenachrichtigung übereinstimmt. Wenn eine Übereinstimmung gefunden wird, wird das `value` GraphQL-Schemafeld mit dem `value` des Abonnementbenachrichtigungsfilters verglichen. Im folgenden Beispiel entspricht der `fieldName` Filter dem `service` Feld, das in einem bestimmten GraphQL-Typ definiert ist. Wenn die Benachrichtigungs-Payload ein `service` Feld mit einer `value` Entsprechung von enthält`AWS AppSync`, wird der Filter wie folgt ausgewertet: `true` ``` { "fieldName" : "service", "operator" : "eq", "value" : "AWS AppSync" } ``` ### Feld: Wert Der Wert kann je nach Operator einen anderen Typ haben: + Eine einzelne Zahl oder ein boolescher Wert + Beispiele für Zeichenketten:, `"test"` `"service"` + Beispiele für Zahlen:`1`,`2`, `45.75` + Boolesche Beispiele:, `true` `false` + Zahlen- oder Zeichenkettenpaare + Beispiel für ein Zeichenkettenpaar:`["test1","test2"]`, `["start","end"]` + Beispiel für ein Zahlenpaar:`[1,4]`,`[67,89]`, `[12.45, 95.45]` + Reihen von Zahlen oder Zeichenketten + Beispiel für ein String-Array: `["test1","test2","test3","test4","test5"]` + Beispiel für ein Zahlenarray:`[1,2,3,4,5]`, `[12.11,46.13,45.09,12.54,13.89]` ### Feld: Operator Eine Zeichenfolge, bei der Groß- und Kleinschreibung beachtet wird, mit den folgenden möglichen Werten: | | | Operator | Description | Mögliche Wertetypen | | --- |--- |--- | | eq | Gleich | Ganzzahl, Gleitkommazahl, Zeichenfolge, Boolean | | Eins | Ungleich | Ganzzahl, Gleitkommazahl, Zeichenfolge, Boolean | | le | Kleiner als oder gleich | Ganzzahl, Gleitkommazahl, Zeichenfolge | | lt | Kleiner als | Ganzzahl, Fließkommazahl, Zeichenfolge | | ge | Größer als oder gleich | Ganzzahl, Gleitkommazahl, Zeichenfolge | | gt | Größer als | Ganzzahl, Fließkommazahl, Zeichenfolge | | enthält | Prüft, ob eine Teilsequenz oder ein Wert in der Menge vorhanden ist. | Ganzzahl, Fließkommazahl, Zeichenfolge | | Nicht enthält | Prüft, ob eine Teilsequenz oder ein Wert in der Menge fehlt. | Ganzzahl, Fließkommazahl, Zeichenfolge | | Beginnt mit | Sucht nach einem Präfix. | Zeichenfolge | | in | Prüft auf übereinstimmende Elemente in der Liste. | Array aus Ganzzahl, Gleitkommazahl oder Zeichenfolge | | notIn | Sucht nach passenden Elementen, die nicht in der Liste enthalten sind. | Array aus Ganzzahl, Gleitkommazahl oder Zeichenfolge | | zwischen | Zwischen zwei Werten | Ganzzahl, Gleitkommazahl, Zeichenfolge | | Enthält Beliebig | Enthält gemeinsame Elemente | Ganzzahl, Fließkommazahl, Zeichenfolge | In der folgenden Tabelle wird beschrieben, wie die einzelnen Operatoren in der Abonnementbenachrichtigung verwendet werden. ------ #### [ eq (equal) ] Der `eq` Operator prüft, `true` ob der Wert des Felds für die Abonnementbenachrichtigung dem Wert des Filters entspricht und diesem genau entspricht. Im folgenden Beispiel bewertet der Filter, `true` ob die Abonnementbenachrichtigung ein `service` Feld enthält, dessen Wert entspricht. `AWS AppSync` **Mögliche Werttypen:** Integer, Float, String, Boolean ``` { "fieldName" : "service", "operator" : "eq", "value" : "AWS AppSync" } ``` ------ #### [ ne (not equal) ] Der `ne` Operator prüft, `true` ob sich der Wert des Felds für die Abonnementbenachrichtigung vom Wert des Filters unterscheidet. Im folgenden Beispiel prüft der Filter, `true` ob die Abonnementbenachrichtigung ein `service` Feld mit einem anderen Wert als enthält. `AWS AppSync` **Mögliche Werttypen:** Integer, Float, String, Boolean ``` { "fieldName" : "service", "operator" : "ne", "value" : "AWS AppSync" } ``` ------ #### [ le (less or equal) ] Der `le` Operator prüft, `true` ob der Wert des Felds für die Abonnementbenachrichtigung kleiner oder gleich dem Wert des Filters ist. Im folgenden Beispiel bewertet der Filter, `true` ob die Abonnementbenachrichtigung ein `size` Feld enthält, dessen Wert kleiner oder gleich ist. `5` **Mögliche Werttypen:** Integer, Float, String ``` { "fieldName" : "size", "operator" : "le", "value" : 5 } ``` ------ #### [ lt (less than) ] Der `lt` Operator prüft, `true` ob der Wert des Felds für die Abonnementbenachrichtigung niedriger als der Wert des Filters ist. Im folgenden Beispiel bewertet der Filter, `true` ob die Abonnementbenachrichtigung ein `size` Feld mit einem niedrigeren Wert als enthält. `5` **Mögliche Werttypen:** Integer, Float, String ``` { "fieldName" : "size", "operator" : "lt", "value" : 5 } ``` ------ #### [ ge (greater or equal) ] Der `ge` Operator prüft, `true` ob der Wert des Felds für die Abonnementbenachrichtigung größer oder gleich dem Wert des Filters ist. Im folgenden Beispiel bewertet der Filter, `true` ob die Abonnementbenachrichtigung ein `size` Feld enthält, dessen Wert größer oder gleich ist. `5` **Mögliche Werttypen:** Integer, Float, String ``` { "fieldName" : "size", "operator" : "ge", "value" : 5 } ``` ------ #### [ gt (greater than) ] Der `gt` Operator prüft, `true` ob der Wert des Felds für die Abonnementbenachrichtigung größer als der Wert des Filters ist. Im folgenden Beispiel bewertet der Filter, `true` ob die Abonnementbenachrichtigung ein `size` Feld mit einem Wert größer als enthält. `5` **Mögliche Werttypen:** Integer, Float, String ``` { "fieldName" : "size", "operator" : "gt", "value" : 5 } ``` ------ #### [ contains ] Der `contains` Operator sucht nach einer Teilzeichenfolge, Teilsequenz oder einem Wert in einer Menge oder einem einzelnen Element. Ein Filter mit dem `contains` Operator überprüft, `true` ob der Wert des Felds für die Abonnementbenachrichtigung den Filterwert enthält. Im folgenden Beispiel überprüft der Filter, `true` ob die Abonnementbenachrichtigung ein `seats` Feld enthält, dessen Array-Wert den Wert enthält. `10` **Mögliche Werttypen:** Integer, Float, String ``` { "fieldName" : "seats", "operator" : "contains", "value" : 10 } ``` In einem anderen Beispiel überprüft der Filter, `true` ob die Abonnementbenachrichtigung ein `event` Feld mit einer `launch` Teilzeichenfolge enthält. ``` { "fieldName" : "event", "operator" : "contains", "value" : "launch" } ``` ------ #### [ notContains ] Der `notContains` Operator prüft, ob eine Teilzeichenfolge, eine Teilsequenz oder ein Wert in einer Gruppe oder einem einzelnen Element fehlt. Der Filter mit dem `notContains` Operator ermittelt, `true` ob der Wert im Feld für die Abonnementbenachrichtigung den Filterwert nicht enthält. Im folgenden Beispiel überprüft der Filter, `true` ob die Abonnementbenachrichtigung ein `seats` Feld enthält, dessen Array-Wert den Wert nicht enthält. `10` **Mögliche Werttypen:** Integer, Float, String ``` { "fieldName" : "seats", "operator" : "notContains", "value" : 10 } ``` In einem anderen Beispiel überprüft der Filter, `true` ob die Abonnementbenachrichtigung einen `event` Feldwert ohne `launch` Untersequenz enthält. ``` { "fieldName" : "event", "operator" : "notContains", "value" : "launch" } ``` ------ #### [ beginsWith ] Der `beginsWith` Operator sucht nach einem Präfix in einer Zeichenfolge. Der Filter, der den `beginsWith` Operator enthält, bewertet, `true` ob der Wert des Felds für die Abonnementbenachrichtigung mit dem Wert des Filters beginnt. Im folgenden Beispiel überprüft der Filter, `true` ob die Abonnementbenachrichtigung ein `service` Feld enthält, dessen Wert mit beginnt. `AWS` **Möglicher Wertetyp: Zeichenfolge** ``` { "fieldName" : "service", "operator" : "beginsWith", "value" : "AWS" } ``` ------ #### [ in ] Der `in` Operator sucht nach passenden Elementen in einem Array. Der Filter, der den `in` Operator enthält, überprüft, `true` ob der Wert des Felds für die Abonnementbenachrichtigung in einem Array vorhanden ist. Im folgenden Beispiel bewertet der Filter, `true` ob die Abonnementbenachrichtigung ein `severity` Feld mit einem der im Array vorhandenen Werte enthält:. `[1,2,3]` **Möglicher Wertetyp:** Array mit Integer, Float oder String ``` { "fieldName" : "severity", "operator" : "in", "value" : [1,2,3] } ``` ------ #### [ notIn ] Der `notIn` Operator sucht nach fehlenden Elementen in einem Array. Der Filter, der den `notIn` Operator enthält, gibt aus, `true` ob der Wert des Felds für die Abonnementbenachrichtigung nicht im Array vorhanden ist. Im folgenden Beispiel bewertet der Filter, `true` ob die Abonnementbenachrichtigung ein `severity` Feld mit einem der Werte enthält, die nicht im Array vorhanden sind:. `[1,2,3]` **Möglicher Wertetyp:** Array mit Integer, Float oder String ``` { "fieldName" : "severity", "operator" : "notIn", "value" : [1,2,3] } ``` ------ #### [ between ] Der `between` Operator sucht nach Werten zwischen zwei Zahlen oder Zeichenketten. Der Filter, der den `between` Operator enthält, überprüft, `true` ob der Wert des Felds für die Abonnementbenachrichtigung zwischen dem Wertepaar des Filters liegt. Im folgenden Beispiel überprüft der Filter, `true` ob die Abonnementbenachrichtigung ein `severity` Feld mit den Werten`2`,, `3` enthält. `4` **Mögliche Werttypen:** Paar aus Integer, Float oder String ``` { "fieldName" : "severity", "operator" : "between", "value" : [1,5] } ``` ------ #### [ containsAny ] Der `containsAny` Operator sucht nach gemeinsamen Elementen in Arrays. Ein Filter mit dem `containsAny` Operator überprüft, `true` ob der Schnittpunkt zwischen dem eingestellten Wert des Felds für die Abonnementbenachrichtigung und dem eingestellten Wert des Filters nicht leer ist. Im folgenden Beispiel überprüft der Filter, `true` ob die Abonnementbenachrichtigung ein `seats` Feld mit einem Array-Wert enthält, der entweder oder `10` enthält. `15` Das bedeutet, dass der Filter auswertet, `true` ob die Abonnementbenachrichtigung den `seats` Feldwert `[10,11]` oder `[15,20,30]` hat. **Mögliche Werttypen:** Integer, Float oder String ``` { "fieldName" : "seats", "operator" : "containsAny", "value" : [10, 15] } ``` ------ ### UND-Logik Sie können mehrere Filter mithilfe der UND-Logik kombinieren, indem Sie mehrere Einträge innerhalb des `filters` Objekts im `filterGroup` Array definieren. Im folgenden Beispiel werten Filter aus, `true` ob die Abonnementbenachrichtigung ein `userId` Feld mit einem Wert enthält, der `1` AND `group` dem Feldwert entweder `Admin` oder entspricht`Developer`. ``` { "filterGroup": [ { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 }, { "fieldName" : "group", "operator" : "in", "value" : ["Admin", "Developer"] } ] } ] } ``` ### ODER-Logik Sie können mehrere Filter mithilfe der OR-Logik kombinieren, indem Sie mehrere Filterobjekte innerhalb des `filterGroup` Arrays definieren. Im folgenden Beispiel werten Filter aus, `true` ob die Abonnementbenachrichtigung ein `userId` Feld mit einem Wert enthält, der `1` ODER einem `group` Feldwert von entweder `Admin` oder entspricht`Developer`. ``` { "filterGroup": [ { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 } ] }, { "filters" : [ { "fieldName" : "group", "operator" : "in", "value" : ["Admin", "Developer"] } ] } ] } ``` ### Ausnahmen Beachten Sie, dass es mehrere Einschränkungen für die Verwendung von Filtern gibt: + Im `filters` Objekt können maximal fünf eindeutige `fieldName` Elemente pro Filter vorhanden sein. Das bedeutet, dass Sie maximal fünf einzelne `fieldName` Objekte mithilfe der UND-Logik kombinieren können. + Für den `containsAny` Operator können maximal zwanzig Werte angegeben werden. + Für die `notIn` Operatoren `in` und können maximal fünf Werte angegeben werden. + Jede Zeichenfolge kann maximal 256 Zeichen lang sein. + Bei jedem Zeichenkettenvergleich wird zwischen Groß- und Kleinschreibung unterschieden. + Die Filterung verschachtelter Objekte ermöglicht bis zu fünf verschachtelte Filterebenen. + Jede `filterGroup` kann maximal 10 haben. `filters` Das bedeutet, dass Sie maximal 10 `filters` mithilfe der ODER-Logik kombinieren können. + Der `in` Operator ist ein Sonderfall der OR-Logik. Im folgenden Beispiel gibt es zwei`filters`: ``` { "filterGroup": [ { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 }, { "fieldName" : "group", "operator" : "in", "value" : ["Admin", "Developer"] } ] } ] } ``` Die vorherige Filtergruppe wird wie folgt ausgewertet und auf die maximale Filtergrenze angerechnet: ``` { "filterGroup": [ { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 }, { "fieldName" : "group", "operator" : "eq", "value" : "Admin" } ] }, { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 }, { "fieldName" : "group", "operator" : "eq", "value" : "Developer" } ] } ] } ``` ## Argument: invalidationJsonObject Das `invalidationJsonObject` definiert Folgendes: + `subscriptionField`— Das GraphQL-Schemaabonnement, das ungültig werden soll. Ein einzelnes Abonnement, das als Zeichenfolge in der definiert ist`subscriptionField`, wird für ungültig erklärt. + `payload`— Eine Liste mit Schlüssel-Wert-Paaren, die als Eingabe für die Ungültigerklärung von Abonnements verwendet wird, wenn der Invalidierungsfilter A anhand ihrer Werte auswertet. `true` Im folgenden Beispiel werden abonnierte und verbundene Clients, die das Abonnement verwenden, ungültig gemacht, wenn der im `onUserDelete` Abonnement-Resolver definierte Invalidierungsfilter das Ergebnis anhand des Werts auswertet. `true` `payload` ``` $extensions.invalidateSubscriptions({ "subscriptionField": "onUserDelete", "payload": { "group": "Developer" "type" : "Full-Time" } }) ```