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.

# Arbeiten mit Direktiven für ein GraphQL-Schema
<a name="tools-graphql-schema-with-directives"></a>

Sie können mit einem GraphQL-Schema beginnen, das bereits Direktiven enthält, indem Sie einen Befehl wie den folgenden verwenden:

```
neptune-for-graphql \
  --input-schema-file {{(your GraphQL schema file with directives)}} \
  --create-update-aws-pipeline \
  --create-update-aws-pipeline-name (name for your new GraphQL API) \
  --create-update-aws-pipeline-neptune-endpoint  {{(empty Neptune database endpoint)}}:{{(port number)}} \
  --output-resolver-query-https
```

Sie können Direktiven ändern, die das Hilfsprogramm erstellt hat, oder Ihre eigenen Direktiven zu einem GraphQL-Schema hinzufügen. Hier sind einige Möglichkeiten, mit Direktiven zu arbeiten:

## Das Hilfsprogramm so ausführen, dass es keine Mutationen generiert
<a name="tools-graphql-no-mutations"></a>

Um zu verhindern, dass das Hilfsprogramm Mutationen in der GraphQL-API generiert, verwenden Sie die `--output-schema-no-mutations`-Option im Befehl `neptune-for-graphql`.

## `Die @alias -Direktive`
<a name="tools-graphql-alias-directive"></a>

Die `@alias`-Direktive kann auf GraphQL-Schematypen oder -Felder angewendet werden. Es ordnet verschiedene Namen zwischen der Graphdatenbank und dem GraphQL-Schema zu. Die Syntax lautet wie folgt:

```
@alias(property: {{(property name)}})
```

Im folgenden Beispiel `airport` ist die Graphdatenbankknotenbezeichnung dem GraphQL-Typ `Airport` zugeordnet, und `desc` es ist die Graphknoteneigenschaft, die dem `description`-Feld zugeordnet ist (siehe das Beispiel [Air Routes](tools-graphql.md)):

```
type Airport @alias(property: "airport") {
  city: String
  description: String @alias(property: "desc")
}
```

Beachten Sie, dass die standardmäßige GraphQL-Formatierung Pascal-casing Typnamen und Feldnamen in Kamelform erfordert.

## `Die @relationship -Direktive`
<a name="tools-graphql-relationship-directive"></a>

Die `@relationship`-Direktive ordnet verschachtelte GraphQL-Typen den Edges von Graphdatenbanken zu. Die Syntax lautet wie folgt:

```
@relationship(edgeType: {{(edge name)}}, direction: {{(IN or OUT)}})
```

Hier sehen Sie ein Beispiel für einen Befehl.

```
type Airport @alias(property: "airport") {
  ...
  continentContainsIn: Continent @relationship(edgeType: "contains", direction: IN)
  countryContainsIn: Country @relationship(edgeType: "contains", direction: IN)
  airportRoutesOut(filter: AirportInput, options: Options): [Airport] @relationship(edgeType: "route", direction: OUT)
  airportRoutesIn(filter: AirportInput, options: Options): [Airport] @relationship(edgeType: "route", direction: IN)
}
```

`@relationship`-Direktiven finden Sie sowohl im [Todo-Beispiel](tools-graphql-start-from-schema.md#tools-graphql-todo-example) als auch im [Air Routes-Beispiel](tools-graphql.md).

## Die Direktiven `@graphQuery` und `@cypher`
<a name="tools-graphql-graphquery-cypher-directives"></a>

Sie können openCypher-Abfragen definieren, um einen Feldwert aufzulösen, Abfragen hinzuzufügen oder Mutationen hinzuzufügen. Dadurch wird dem `Airport`-Typ beispielsweise ein neues `outboundRoutesCount`-Feld hinzugefügt, um die ausgehenden Routen zu zählen:

```
type Airport @alias(property: "airport") {
  ...
  outboundRoutesCount: Int @graphQuery(statement: "MATCH (this)-[r:route]->(a) RETURN count(r)")
}
```

Hier ein Beispiel für neue Abfragen und Mutationen:

```
type Query {
  getAirportConnection(fromCode: String!, toCode: String!): Airport \
    @cypher(statement: \
      "MATCH (:airport{code: '$fromCode'})-[:route]->(this:airport)-[:route]->(:airport{code:'$toCode'})")
}

type Mutation {
  createAirport(input: AirportInput!): Airport @graphQuery(statement: "CREATE (this:airport {$input}) RETURN this")
  addRoute(fromAirportCode:String, toAirportCode:String, dist:Int): Route \
    @graphQuery(statement: \
     "MATCH (from:airport{code:'$fromAirportCode'}), (to:airport{code:'$toAirportCode'}) \
      CREATE (from)-[this:route{dist:$dist}]->(to) \
      RETURN this")
}
```

Beachten Sie, dass, wenn Sie `RETURN` weglassen, der Resolver annimmt, dass das Schlüsselwort `this` der zurückkehrende Bereich ist.

Sie können eine Abfrage oder Mutation auch mithilfe einer Gremlin-Abfrage hinzufügen:

```
type Query {
  getAirportWithGremlin(code:String): Airport \
    @graphQuery(statement: "g.V().has('airport', 'code', '$code').elementMap()")  # single node
  getAirportsWithGremlin: [Airport] \
    @graphQuery(statement: "g.V().hasLabel('airport').elementMap().fold()")       # list of nodes
  getCountriesCount: Int \
    @graphQuery(statement: "g.V().hasLabel('country').count()")                   # scalar
}
```

Derzeit sind Gremlin-Abfragen auf Abfragen beschränkt, die Skalarwerte zurückgeben, oder `elementMap()` für einen einzelnen Knoten oder `elementMap().fold()` für eine Liste von Knoten.

## Die `@id -Direktive`
<a name="tools-graphql-id-directive"></a>

Die `@id`-Direktive identifiziert das Feld, das der `id` Graphdatenbank-Entität zugeordnet ist. Graphdatenbanken wie Amazon Neptune haben immer eine eindeutige `id` für Knoten und Edges, die bei Massenimporten zugewiesen oder automatisch generiert wird. Beispiel:

```
type Airport {
  _id: ID! @id
  city: String
  code: String
}
```

## Reservierte Typ-, Abfrage- und Mutationsnamen
<a name="tools-graphql-reserved-names"></a>

Das Hilfsprogramm generiert automatisch Abfragen und Mutationen, um eine funktionierende GraphQL-API zu erstellen. Das Muster dieser Namen wird vom Resolver erkannt und ist reserviert. Hier sind Beispiele für den Typ `Airport` und den Verbindungstyp `Route`:

Der Name `Options` ist reserviert.

```
input Options {
  limit: Int
}
```

Die Funktionsparameter `filter` und `options` sind reserviert.

```
type Query {
  getNodeAirports(filter: AirportInput, options: Options): [Airport]
}
```

Das GetNode-Präfix von Abfragenamen ist reserviert, und Präfixe von Mutationsnamen wie `createNode`, `updateNode`, `deleteNode`, `connectNode`, `deleteNode`, `updateEdge` und `deleteEdge` sind reserviert.

```
type Query {
  getNodeAirport(id: ID, filter: AirportInput): Airport
  getNodeAirports(filter: AirportInput): [Airport]
}

type Mutation {
  createNodeAirport(input: AirportInput!): Airport
  updateNodeAirport(id: ID!, input: AirportInput!): Airport
  deleteNodeAirport(id: ID!): Boolean
  connectNodeAirportToNodeAirportEdgeRout(from: ID!, to: ID!, edge: RouteInput!): Route
  updateEdgeRouteFromAirportToAirport(from: ID!, to: ID!, edge: RouteInput!): Route
  deleteEdgeRouteFromAirportToAirport(from: ID!, to: ID!): Boolean
}
```

## Änderungen am GraphQL-Schema anwenden
<a name="tools-graphql-apply-schema-changes"></a>

Sie können das GraphQL-Quellschema ändern und das Hilfsprogramm erneut ausführen, um das neueste Schema aus Ihrer Neptune-Datenbank abzurufen. Jedes Mal, wenn das Hilfsprogramm ein neues Schema in der Datenbank entdeckt, generiert es ein neues GraphQL-Schema.

Sie können das GraphQL-Quellschema auch manuell bearbeiten und das Hilfsprogramm erneut ausführen, indem Sie das Quellschema als Eingabe anstelle des Neptune-Datenbankendpunkts verwenden.

Schließlich können Sie Ihre Änderungen mit diesem JSON-Format in eine Datei einfügen:

```
[
  {
    "type": "{{(GraphQL type name)}}",
    "field": "{{(GraphQL field name)}}",
    "action": "{{(remove or add)}}",
    "value": "{{(value)}}"
  }
]
```

Beispiel:

```
[
  {
    "type": "Airport",
    "field": "outboundRoutesCountAdd",
    "action": "add",
    "value":"outboundRoutesCountAdd: Int @graphQuery(statement: \"MATCH (this)-[r:route]->(a) RETURN count(r)\")"
  },
  {
    "type": "Mutation",
    "field": "deleteNodeVersion",
    "action": "remove",
    "value": ""
  },
  {
    "type": "Mutation",
    "field": "createNodeVersion",
    "action": "remove",
    "value": ""
  }
]
```

Wenn Sie dann das Hilfsprogramm mithilfe des `--input-schema-changes-file`-Parameters im Befehl für diese Datei ausführen, wendet das Hilfsprogramm Ihre Änderungen sofort an.