Qu'est-ce qu'un point d'exclamation dans graphql?

Question

Dans un fichier de schéma que j'ai, j'ai remarqué qu'il y a des points d'exclamation après certains types, comme

 # Information on an account relationship
type AccountEdge {
  cursor: String!
  node: Account!
}
 

Qu'est-ce que cela signifie? Je ne trouve rien à ce sujet dans la documentation ou sur Google

Answer 1

Cela signifie que le champ n'est pas nullable.

Voir plus d'informations dans Graphql - Schémas et types

Answer 2

À partir de la spec:

Par défaut, tous les types de GraphQL sont nullable; la valeur null est une réponse valable pour tous les types ci-dessus. Pour déclarer un type qui n'autorise pas la valeur null, le GraphQL Non‐Nulle de type peut être utilisé. Ce type emballe un type sous-jacent, et ce type d'actes de façon identique à celle enveloppée type, à l'exception que null n'est pas une réponse valide pour le type d'emballage. Un point d'exclamation est utilisé pour désigner un domaine qui utilise une valeur Non Nulle de type comme ceci: nom: String!.

En d'autres termes, les types de GraphQL sont les valeurs null par défaut. Un point d'exclamation après un type désigne spécifiquement ce type ne peut pas être null.

Cela a des conséquences différentes selon l'endroit où le type est utilisé.

Sortie

Lorsque la non-nulle est appliquée pour le type d'un champ, cela signifie que si le serveur décide que le champ d' null, la réponse sera la validation échoue. Vous pouvez toujours recevoir une réponse partielle, tant que l'erreur ne peut pas se propager tout le chemin jusqu'à la racine.

Par exemple, étant donné un schéma comme:

type Query {
  user: User
}

type User {
  id: ID!
}

Ici l' id champ est non-nulle. En marquant le champ en tant que non-nulle, nous sommes en mesure de garantir jamais nous ne pourrons nous retourner la valeur null pour ce champ. Si le serveur ne retourne la valeur null, alors c'est une indication que quelque chose a terriblement mal et nous voulons jeter une erreur de validation.

Entrée

Lorsque la non-nulle est appliquée pour le type de l' entrée, comme un argument, d'entrée de champ d'objet ou une variable, de fait, des données d'entrée requises. Par exemple:

type Query {
  getUser(id: ID!, status: Status): User
}

Ici, l' id argument est non-nulle. Si l'on demande l' getUser domaine, nous sommes toujours prêts à fournir l' id argument. D'autre part, parce que l' status argument est nullable, c'est facultatif et peut être omis. Cela s'applique à des variables ainsi:

query MyQuery ($foo: ID!) {
  getUser(id: $foo)
}

Parce que l' $foo variable est non nulle, lorsque vous envoyez la requête, il ne peut pas être omis, sa valeur ne peut pas égaler null.

Une note spéciale sur les types de variables

Parce que l' id champ est une valeur non null ID (c - ID!) type dans notre exemple, la variable que nous passons, il doit aussi être un non-nulles ID. Si notre $foo variable a été nullable ID, nous ne pouvions pas passer à l' id argument. À l'opposé, cependant, n'est pas vrai. Si un argument est nullable, vous pouvez passer une valeur non nulle de la variable.

En d'autres termes:

+----------+----------+--------+
| Argument | Variable | Valid? |
+----------+----------+--------+
| String   | String   |   ✅   |
| String   | String!  |   ✅   |
| String!  | String   |   ❌   |
| String!  | String!  |   ✅   |
+----------+----------+--------+