GraphQL | escalares

Los escalares son contenido del sistema de tipos GraphQL. Los escalares de GraphQL son los tipos de valor en los que finalmente se resuelve cada campo en un documento de GraphQL. Son los tipos de datos primitivos los que almacenan un valor único. Hay cinco escalares integrados en GraphQL, pero también puede definir escalares personalizados.

Escalares integrados : los tipos escalares representan valores de hoja primitivos en un sistema de tipos GraphQL. Las respuestas de GraphQL toman la forma de un árbol jerárquico; las hojas de estos árboles son escalares GraphQL.

• int: representa un valor numérico de número entero con signo de 32 bits. El servidor que responde como Int debe usar esta especificación Int.
• float: Representa valores fraccionarios con signo de doble precisión. Para definir esta especificación, se utiliza el estándar IEEE 754.
• string: Representa texto en codificación UTF-8.
• Booleano: este escalar es verdadero o falso.
• id: identificador único utilizado con fines de identificación (que actúa como clave) de los datos. El ID se trata como un String para su serialización. La serialización está transformando un objeto a booleano, número o string aquí.

Ejemplo: Estructura de GraphQL Escalar.

• Consulta:

  {
    pokemon {
      name
      pokemonDetails
    }
  }

• Producción:

  {
   "data": {
     "pokemon": {
        "name":"Bulbasaur",
        "pokemonDetails": {
           "typePokemon":"land",
           "levelPokemon":3
         }
      }
    }
  }

Los escalares GraphQL tienen 3 métodos. El propósito de estos métodos es la identificación y validación de los datos antes de que se transfieran entre el cliente y el servidor.

• Validación: los datos que se pasan entre el cliente y el servidor se validan para que sean de un tipo específico, de modo que el receptor pueda manejarlos correctamente. Esta validación debe colocarse en todos los puntos apropiados donde se requiera tal validación. ( <-medios del validador <-validador<-cliente )
• Serialización: antes de transferir los datos, se serializan para convertirlos a un tipo apropiado para la transmisión. Por ejemplo, un objeto JSON complejo que contiene los detalles de un estudiante se serializa en una string y luego se envía.
• Análisis: cuando se reciben los datos (serializados por el lado del remitente), se analizan para convertirlos en una forma adecuada. Por ejemplo, el emisor serializa un objeto Fecha y lo envía al receptor. Luego, el receptor lo analiza para volver a convertirlo en el objeto Fecha.

Escalares personalizados: GraphQL brinda a los desarrolladores el poder de definir escalares personalizados, adecuados a sus propias necesidades. Podemos declarar un escalar personalizado como el siguiente y agregarlo al esquema. Para definir su propio escalar, las validaciones, serializaciones y analizadores deben escribirse desde cero. También hay un gran paquete llamado graphql-scalars listo para usar que contiene escalares comunes que podrían ser necesarios.

• Sintaxis:

  scalar customScalar

Ejemplo: ahora, veamos algunos ejemplos de cómo se desarrollan estos escalares. Para la demostración, usaremos el siguiente archivo schema.js para realizar esta tarea.

• esquema.js:

  type Attack {
    name: String
    type: String
    damage: Int
  }
  
  type Pokemon {
    id: ID!
    number: String
    name: String
    weight: PokemonDimension
    height: PokemonDimension
    classification: String
    types: [String]
    resistant: [String]
    attacks: PokemonAttack
    weaknesses: [String]
    fleeRate: Float
    maxCP: Int
    evolutions: [Pokemon]
    evolutionRequirements: PokemonEvolutionRequirement
    maxHP: Int
    image: String
  }
  
  type PokemonAttack {
    fast: [Attack]
    special: [Attack]
  }
  
  type PokemonDimension {
    minimum: String
    maximum: String
  }
  
  type PokemonEvolutionRequirement {
    amount: Int
    name: String
  }
  
  type Query {
    query: Query
    pokemons(first: Int!): [Pokemon]
    pokemon(id: String, name: String): Pokemon
  }

• Producción:
  

Características de los escalares:

• En su mayor parte, GraphQL Scalars ayuda en el funcionamiento básico del motor GraphQL. Lo hacen proporcionando los cinco «tipos de valor» básicos para «campos» que se pueden transferir entre el servidor y el cliente. Estos tipos básicos son: Int, Float, String, Boolean e ID.
• Para el software que es un poco más complejo, GraphQL proporciona al programador la capacidad de definir ‘tipos escalares personalizados’ para manejar mejor las ‘Operaciones de GraphQL’ (en términos de eficiencia, eficacia y seguridad)
• Los escalares incorporados de GraphQL también tienen un tipo de valor ‘id’ que se puede usar para etiquetar de forma única cada registro de datos.
• Los escalares de GraphQL se utilizan para crear esquemas que actúan como modelo para recuperar datos de la base de datos.

Referencia: https://graphql-ruby.org/type_definitions/scalars.html