Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Propiedades adicionales de GraphQL
<a name="graphql-properties"></a>

GraphQL consta de varios principios de diseño para mantener la simplicidad y la solidez a escala.

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

GraphQL es declarativo, lo que significa que el usuario describirá (dará forma) a los datos declarando únicamente los campos que desee consultar. La respuesta solo devolverá los datos de estas propiedades. Por ejemplo, esta es una operación que recupera un `Book` objeto de una tabla de DynamoDB con el valor ISBN 13 de: `id` *9780199536061*

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

La respuesta devolverá los campos de la carga (`name`, `year` y `author`) y nada más:

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

Gracias a este principio de diseño, GraphQL elimina los problemas perennes de sobreprocesamiento o subprocesamiento que REST plantea en sistemas APIs complejos. Esto se traduce en una recopilación de datos más eficiente y en un mejor rendimiento de la red.

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

GraphQL es flexible en el sentido de que el usuario puede configurar los datos solicitados para adaptarlos a las necesidades de la aplicación. Los datos solicitados siempre siguen los tipos y la sintaxis de las propiedades definidas en la API de GraphQL. Por ejemplo, en el siguiente fragmento se muestra la `getBook` operación con un nuevo campo denominado `quotes` que devuelve todas las cadenas de comillas almacenadas y las páginas enlazadas a: `Book` *9780199536061*

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

Al ejecutar esta consulta, se devuelve el resultado siguiente:

```
{
  "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 puede ver, los campos `quotes` vinculados al libro solicitado se han devuelto como una matriz con el mismo formato descrito en nuestra consulta. Aunque no se ha mostrado aquí, GraphQL tiene la ventaja adicional de no ser exigente en cuanto a la ubicación de los datos que recupera. Los `Books` y las `quotes` podría almacenarse por separado, pero GraphQL seguirá recuperando la información mientras exista la asociación. Esto significa que su consulta puede recuperar múltiples datos independientes en una sola solicitud.

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

GraphQL se documenta automáticamente o es declarativo. Admite varias operaciones integradas que permiten a los usuarios ver los tipos y campos subyacentes dentro del esquema. Por ejemplo, este es un tipo `Foo` con un campo `date` y `description`:

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

Podríamos usar la operación `_type` para buscar los metadatos de escritura que se encuentran debajo del 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
      }
    }
  }
}
```

Se devolverá una respuesta:

```
{
  "__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
      },
    ]
  }
}
```

Esta característica se puede utilizar para averiguar qué tipos y campos admite un esquema de GraphQL en particular. GraphQL admite una amplia variedad de estas operaciones introspectivas. Para obtener más información, consulte [Introspección](https://graphql.org/learn/introspection/).

## Tipado fuerte
<a name="strong-typing-property"></a>

GraphQL admite el tipado fuerte a través de su sistema de tipos y campos. Cuando defina algo en su esquema, debe tener un tipo que pueda validarse antes de su tiempo de ejecución. También debe seguir la especificación de sintaxis de GraphQL. Este concepto no es diferente de la programación en otros lenguajes. Por ejemplo, este es el tipo `Foo` de antes:

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

Podemos ver que ese `Foo` es el objeto que se va a crear. Dentro de una instancia de `Foo`, habrá un campo `date` y otro `description`, ambos del tipo primitivo (escalar) `String`. Sintácticamente, vemos que `Foo` se ha declarado y que sus campos están dentro de su ámbito. Esta combinación de comprobación de tipos y sintaxis lógica garantiza que la API de GraphQL sea concisa y evidente por sí misma. La especificación de tipos y sintaxis de GraphQL se encuentra [aquí](https://spec.graphql.org/).