web-dev-qa-db-fra.com

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

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

graphql
22
JuanCaicedo

Cela signifie que le champ n'est pas nullable.

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

26
Juan

De la spec :

Par défaut, tous les types de GraphQL sont nullables; la valeur nulle est une réponse valide pour tous les types ci-dessus. Pour déclarer un type qui interdit null, le type GraphQL Non-Null peut être utilisé. Ce type encapsule un type sous-jacent et ce type agit de manière identique à ce type encapsulé, à l'exception que null n'est pas une réponse valide pour le type encapsulé. Un point d'exclamation de fin est utilisé pour indiquer un champ qui utilise un type non Null comme celui-ci: name: String !.

En d'autres termes, les types dans GraphQL sont nullables par défaut. Un point d'exclamation après un type désigne spécifiquement ce type comme non nul.

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

Sortie

Lorsqu'une valeur non nulle est appliquée au type d'un champ , cela signifie que si le serveur résout ce champ en null, la réponse échouera la validation. Vous pouvez toujours recevoir une réponse partielle, tant que l'erreur ne --- se propage jusqu'à la racine .

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

type Query {
  user: User
}

type User {
  id: ID!
}

Ici, le champ id n'est pas nul. En marquant le champ comme non nul, nous sommes effectivement garantissant nous ne retournerons jamais null pour ce champ. Si le serveur retourne null, c'est une indication que quelque chose s'est terriblement mal passé et nous voulons lancer une erreur de validation.

Contribution

Lorsqu'une valeur non nulle est appliquée au type d'une entrée , comme un argument, un champ d'objet d'entrée ou une variable, cela rend cette entrée requise. Par exemple:

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

Ici, l'argument id n'est pas nul. Si nous demandons le champ getUser, nous devrons toujours lui fournir l'argument id. En revanche, comme l'argument status est nullable, il est facultatif et peut être omis. Cela s'applique également aux variables:

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

Parce que le $foo la variable n'est pas nulle, lorsque vous envoyez la requête, elle ne peut pas être omise et sa valeur ne peut pas être égale à null.

Une note spéciale sur les types variables

Parce que le champ id est un ID non nul (c'est-à-dire ID!) dans notre exemple, toute variable que nous lui transmettons doit également être un ID non nul. Si notre $foo variable était un ID nullable, nous n'avons pas pu le passer à l'argument id. L'inverse, cependant, n'est pas vrai. Si un argument est nullable, vous pouvez lui passer une variable non nulle.

En d'autres termes:

+----------+----------+--------+
| Argument | Variable | Valid? |
+----------+----------+--------+
| String   | String   |   ✅   |
| String   | String!  |   ✅   |
| String!  | String   |   ❌   |
| String!  | String!  |   ✅   |
+----------+----------+--------+
3
Daniel Rearden