As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Trabalhar com diretivas para um esquema do GraphQL
<a name="tools-graphql-schema-with-directives"></a>

É possível partir de um esquema do GraphQL que já tenha diretivas, usando um comando como o seguinte:

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

Você pode modificar as diretivas que o utilitário criou ou adicionar as próprias diretivas a um esquema do GraphQL. Aqui estão algumas maneiras de trabalhar com diretivas:

## Executar o utilitário para que ele não gere mutações
<a name="tools-graphql-no-mutations"></a>

Para evitar que o utilitário gere mutações na API do GraphQL, use a opção `--output-schema-no-mutations` no comando `neptune-for-graphql`.

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

A diretiva `@alias` pode ser aplicada aos tipos ou aos campos do esquema do GraphQL. Ele associa nomes diferentes entre o banco de dados de grafos e o esquema do GraphQL. A sintaxe é:

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

No exemplo abaixo, `airport` é o rótulo do nó do banco de dados de grafos associado ao tipo `Airport` do GraphQL e `desc` é a propriedade do nó gráfico associada ao campo `description` (veja o [Exemplo de rotas aéreas](tools-graphql.md)):

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

Observe que a formatação padrão do GraphQL exige nomes de tipo Pascal-casing e nomes de campo camel-casing.

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

A diretiva `@relationship` associa tipos de GraphQL a bordas do banco de dados de grafos. A sintaxe é:

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

Veja a seguir um exemplo de comando:

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

Você pode encontrar diretivas `@relationship` no [Exemplo de Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example) e no [Exemplo de rotas aéreas](tools-graphql.md).

## As diretivas `@graphQuery` e `@cypher`
<a name="tools-graphql-graphquery-cypher-directives"></a>

É possível definir consultas do openCypher para resolver um valor de campo, bem como adicionar consultas ou mutações. Por exemplo, isso adiciona um novo campo `outboundRoutesCount` ao tipo `Airport` para contar as rotas de saída:

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

Aqui está um exemplo de novas consultas e mutações:

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

Observe que, se você omitir o `RETURN`, o resolvedor assumirá que a palavra-chave `this` é o escopo de retorno.

Você também pode adicionar uma consulta ou uma mutação usando uma consulta do 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
}
```

No momento, as consultas do Gremlin são limitadas às que geram valores escalares, ou `elementMap()` para um único nó, ou `elementMap().fold()` para uma lista de nós.

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

A diretiva `@id` identifica o campo associada à entidade do banco de dados `id` de grafos. Bancos de dados de grafos, como o Amazon Neptune, sempre têm um `id` exclusivo para nós e bordas que é atribuído durante importações em massa ou gerado automaticamente. Por exemplo:

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

## Nomes reservados de tipo, consulta e mutação
<a name="tools-graphql-reserved-names"></a>

O utilitário gera automaticamente consultas e mutações para criar uma API do GraphQL funcional. O padrão desses nomes é reconhecido pelo resolvedor e é reservado. Aqui estão alguns exemplos do tipo `Airport` e do tipo de conexão `Route`:

O tipo `Options` é reservado.

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

Os parâmetros de função `filter` e `options` são reservados.

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

O prefixo getNode dos nomes das consultas é reservado, e os prefixos de nomes de mutações, como `createNode`, `updateNode`, `deleteNode`, `connectNode`, `deleteNode`, `updateEdge` e `deleteEdge` são reservados.

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

## Aplicar alterações ao esquema do GraphQL
<a name="tools-graphql-apply-schema-changes"></a>

É possível modificar o esquema de origem do GraphQL e executar o utilitário novamente, obtendo o esquema mais recente do seu banco de dados Neptune. Toda vez que o utilitário descobre um novo esquema no banco de dados, ele gera um novo esquema do GraphQL.

Você também pode editar manualmente o esquema de origem do GraphQL e executar o utilitário novamente usando o esquema de origem como entrada em vez do endpoint do banco de dados Neptune.

Por fim, é possível colocar suas alterações em um arquivo usando este formato JSON:

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

Por exemplo:

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

Depois, ao executar o utilitário nesse arquivo usando o parâmetro `--input-schema-changes-file` no comando, o utilitário aplica suas alterações de uma só vez.