Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Bekerja dengan arahan untuk skema GraphQL
<a name="tools-graphql-schema-with-directives"></a>

Anda dapat memulai dari skema GraphQL yang sudah memiliki arahan, menggunakan perintah seperti berikut:

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

Anda dapat memodifikasi arahan yang telah dibuat oleh utilitas atau menambahkan arahan Anda sendiri ke skema GraphQL. Berikut adalah beberapa cara untuk bekerja dengan arahan:

## Menjalankan utilitas sehingga tidak menghasilkan mutasi
<a name="tools-graphql-no-mutations"></a>

Untuk mencegah utilitas menghasilkan muatasi di GraphQL API, gunakan opsi dalam perintah. `--output-schema-no-mutations` `neptune-for-graphql`

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

`@alias`Direktif dapat diterapkan ke jenis atau bidang skema GraphQL. Ini memetakan nama yang berbeda antara database grafik dan skema GraphQL. Sintaksnya adalah:

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

[Dalam contoh di bawah ini `airport` adalah label node database grafik yang dipetakan ke tipe GraphQL, `desc` dan merupakan properti node grafik yang dipetakan ke bidang (lihat Contoh `description` Rute Udara): `Airport`](tools-graphql.md)

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

Perhatikan bahwa pemformatan GraphQL standar memerlukan nama bidang tipe namess dan Pascal-casing camel-casing.

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

`@relationship`Direktif memetakan jenis GraphQL bersarang untuk membuat grafik tepi basis data. Sintaksnya adalah:

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

Berikut adalah contoh perintah:

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

Anda dapat menemukan `@relationship` arahan dalam contoh [Todo dan Contoh](tools-graphql-start-from-schema.md#tools-graphql-todo-example) [Rute Udara](tools-graphql.md).

## Arahan `@graphQuery` dan `@cypher`
<a name="tools-graphql-graphquery-cypher-directives"></a>

Anda dapat menentukan kueri OpenCypher untuk menyelesaikan nilai bidang, menambahkan kueri, atau menambahkan mutasi. Misalnya, ini menambahkan `outboundRoutesCount` bidang baru ke `Airport` tipe untuk menghitung rute outboud:

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

Berikut contoh kueri dan mutasi baru:

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

Perhatikan bahwa jika Anda menghilangkan`RETURN`, resolver mengasumsikan kata kunci `this` adalah lingkup kembali.

Anda juga dapat menambahkan kueri atau mututasi menggunakan kueri Gremlin:

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

Pada saat ini kueri Gremlin terbatas pada kueri yang mengembalikan nilai skalar, atau `elementMap()` untuk satu node, atau `elementMap().fold()` untuk daftar node.

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

`@id`Direktif mengidentifikasi bidang yang dipetakan ke entitas database `id` grafik. Database grafik seperti Amazon Neptunus selalu memiliki `id` keunikan untuk node dan tepi yang ditetapkan selama impor massal atau yang dibuat secara otomatis. Contoh:

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

## Jenis cadangan, kueri, dan nama mutasi
<a name="tools-graphql-reserved-names"></a>

Utilitas membuat kueri dan mutasi secara otomatis untuk membuat GraphQL API yang berfungsi. Pola nama-nama ini dikenali oleh resolver dan dicadangkan. Berikut adalah contoh untuk tipe `Airport` dan tipe penghubung`Route`:

`Options`Tipe ini dicadangkan.

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

Parameter `filter` dan `options` fungsi dicadangkan.

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

Awalan getNode dari nama kueri dicadangkan, dan awalan nama mutasi seperti`createNode`,,,,, `updateNode` `deleteNode` `connectNode``deleteNode`, `updateEdge` dan dicadangkan. `deleteEdge`

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

## Menerapkan perubahan pada skema GraphQL
<a name="tools-graphql-apply-schema-changes"></a>

Anda dapat memodifikasi skema sumber GraphQL dan menjalankan utilitas lagi, mendapatkan skema terbaru dari database Neptunus Anda. Setiap kali utilitas menemukan skema baru dalam database, itu menghasilkan skema GraphQL baru.

Anda juga dapat mengedit skema sumber GraphQL secara manual dan menjalankan utilitas lagi menggunakan skema sumber sebagai input alih-alih titik akhir basis data Neptunus.

Akhirnya, Anda dapat menempatkan perubahan Anda dalam file menggunakan format JSON ini:

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

Contoh:

```
[
  {
    "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": ""
  }
]
```

Kemudian, saat Anda menjalankan utilitas pada file ini menggunakan `--input-schema-changes-file` parameter dalam perintah, utilitas menerapkan perubahan Anda sekaligus.