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á.

# Propriedades adicionais do GraphQL
<a name="graphql-properties"></a>

O GraphQL consiste em vários princípios de design para manter a simplicidade e a robustez em grande escala.

## Declarativo
<a name="declarative-property"></a>

O GraphQL é declarativo, o que significa que o usuário descreverá (moldará) os dados declarando apenas os campos que deseja consultar. A resposta retornará somente os dados dessas propriedades. Por exemplo, aqui está uma operação que recupera um `Book` objeto em uma tabela do DynamoDB com o valor ISBN 13 de: `id` *9780199536061*

```
{
  getBook(id: "9780199536061") {
    name
    year
    author
  }
}
```

A resposta retornará os campos na payload (`name`, `year` e `author`) e nada mais:

```
{
  "data": {
    "getBook": {
      "name": "Anna Karenina",
      "year": "1878",
      "author": "Leo Tolstoy",
    }
  }
}
```

Por causa desse princípio de design, o GraphQL elimina os problemas perenes de busca excessiva e insuficiente que o REST APIs enfrenta em sistemas complexos. Isso resulta em coleta de dados mais eficiente e melhor desempenho da rede.

## Hierárquico
<a name="hierarchical-property"></a>

O GraphQL é flexível, pois os dados solicitados podem ser moldados pelo usuário para atender às necessidades do aplicativo. Os dados solicitados sempre seguem os tipos e a sintaxe das propriedades definidas na sua API GraphQL. Por exemplo, o trecho a seguir mostra a `getBook` operação com um novo escopo de campo chamado `quotes` que retorna todas as cadeias de aspas armazenadas e páginas vinculadas ao: `Book` *9780199536061*

```
{
  getBook(id: "9780199536061") {
    name
    year
    author
    quotes {
      description
      page
    }
  }
}
```

Ao executar esta consulta, retornaremos o seguinte resultado:

```
{
  "data": {
    "getBook": {
      "name": "Anna Karenina",
      "year": "1878",
      "author": "Leo Tolstoy",
      "quotes": [
         {
            "description": "The highest Petersburg society is essentially one: in it everyone knows everyone else, everyone even visits everyone else.",
            "page": 135
         },
         { 
            "description": "Happy families are all alike; every unhappy family is unhappy in its own way.",
            "page": 1
         },
         {        
            "description": "To Konstantin, the peasant was simply the chief partner in their common labor.",
            "page": 251
         }
      ]
    }
  }
}
```

Como você pode ver, os campos `quotes` vinculados ao livro solicitado foram retornados como uma matriz no mesmo formato descrito em nossa consulta. Embora não tenha sido mostrado aqui, o GraphQL tem a vantagem adicional de não ser restrito sobre a localização dos dados que está recuperando. `Books` e `quotes` podem ser armazenados separadamente, mas o GraphQL ainda recuperará as informações enquanto a associação existir. Isso significa que sua consulta pode recuperar vários dados autônomos em uma única solicitação.

## Introspectivo
<a name="introspective-property"></a>

O GraphQL é autodocumentado ou introspectivo. Ele oferece suporte a várias operações integradas que permitem que os usuários visualizem os tipos e campos subjacentes no esquema. Por exemplo, aqui está um tipo `Foo` com um campo `date` e `description`:

```
type Foo {
	date: String
	description: String
}
```

Poderíamos usar a operação `_type` para encontrar os metadados de digitação abaixo do esquema:

```
{
  __type(name: "Foo") {
    name                   # returns the name of the type
    fields {               # returns all fields in the type
      name                 # returns the name of each field
      type {               # returns all types for each field
        name               # returns the scalar type
      }
    }
  }
}
```

Isso retornará uma resposta:

```
{
  "__type": {
    "name": "Foo",                     # The type name
    "fields": [
      {
        "name": "date",                # The date field
        "type": { "name": "String" }   # The date's type
      },
      {
        "name": "description",         # The description field
        "type": { "name": "String" }   # The description's type
      },
    ]
  }
}
```

Esse atributo pode ser usado para descobrir quais tipos e campos um determinado esquema do GraphQL aceita. O GraphQL é compatível com uma ampla variedade dessas operações introspectivas. Para obter mais informações, consulte [Introspecção](https://graphql.org/learn/introspection/).

## Tipificação forte
<a name="strong-typing-property"></a>

O GraphQL oferece suporte a tipificação forte por meio de seu sistema de tipos e campos. Quando você define algo em seu esquema, ele deve ter um tipo que possa ser validado antes do runtime. Ele também deve seguir a especificação de sintaxe do GraphQL. Esse conceito não é diferente da programação em outras linguagens. Por exemplo, este é o tipo `Foo` anterior:

```
type Foo {
	date: String
	description: String
}
```

Podemos ver que esse `Foo` é o objeto que será criado. Dentro de uma instância de `Foo`, haverá um campo `date` e `description`, ambos do tipo primitivo `String` (escalar). Sintaticamente, vemos que `Foo` foi declarado e seus campos existem dentro de seu escopo. Essa combinação de verificação de tipo e sintaxe lógica garante que sua API GraphQL seja concisa e evidente. A especificação de tipificação e sintaxe do GraphQL pode ser encontrada [aqui](https://spec.graphql.org/).