Comment interroger tous les champs de type GraphQL sans écrire une longue requête?

Supposons que vous ayez un type GraphQL et qu'il inclut de nombreux champs. Comment interroger tous les champs sans écrire une longue requête qui inclut les noms de tous les champs?

Par exemple, si j'ai ces champs:

 public function fields()
    {
        return [
            'id' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The id of the user'
            ],
            'username' => [
                'type' => Type::string(),
                'description' => 'The email of user'
            ], 
             'count' => [
                'type' => Type::int(),
                'description' => 'login count for the user'
            ]

        ];
    }

Pour interroger tous les champs, la requête est généralement quelque chose comme ceci:

FetchUsers{users(id:"2"){id,username,count}}

Mais je veux un moyen d'avoir les mêmes résultats sans écrire tous les champs, quelque chose comme ceci:

FetchUsers{users(id:"2"){*}}
//or
FetchUsers{users(id:"2")}

Y a-t-il un moyen de faire cela dans GraphQL ??

J'utilise Folkloreatelier / Laravel-graphql bibliothèque.

Malheureusement, ce que vous aimeriez faire n'est pas possible. GraphQL vous demande d'être explicite sur la spécification des champs que vous souhaitez renvoyer à partir de votre requête.

Oui, vous pouvez le faire en utilisant l' introspection . Faire une requête GraphQL comme (pour le type UserType )

{
   __type(name:"UserType") {
      fields {
         name
         description
      }  
   }
}

et vous obtiendrez une réponse comme (les noms de champ réels dépendront de votre définition réelle de schéma / type)

{
  "data": {
    "__type": {
      "fields": [
        {
          "name": "id",
          "description": ""
        },
        {
          "name": "username",
          "description": "Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."
        },
        {
          "name": "firstName",
          "description": ""
        },
        {
          "name": "lastName",
          "description": ""
        },
        {
         "name": "email",
          "description": ""
        },
        ( etc. etc. ...)
      ]
    }
  }
}

Vous pouvez ensuite lire cette liste de champs dans votre client et créer dynamiquement une deuxième requête GraphQL pour obtenir tous ces champs.

Cela dépend du fait que vous connaissiez le nom du type pour lequel vous souhaitez obtenir les champs - si vous ne connaissez pas le type, vous pouvez rassembler tous les types et champs en utilisant une introspection comme

{
  __schema {
    types {
      name
      fields {
        name
        description
      }
    }
  }
}

REMARQUE: ce sont les données GraphQL over-the-wire - vous êtes seul pour comprendre comment lire et écrire avec votre client réel. Votre bibliothèque javascript graphQL peut déjà utiliser l'introspection dans une certaine capacité, par exemple la commande apollo codegen utilise l'introspection pour générer des types.

Je suppose que le seul moyen de le faire est d'utiliser des fragments réutilisables:

fragment UserFragment on Users {
    id
    username
    count
} 

FetchUsers {
    users(id: "2") {
        ...UserFragment
    }
}

J'ai rencontré le même problème lorsque j'ai eu besoin de charger des données de localisation que j'avais sérialisées dans la base de données à partir de l'API google places. En général, je voudrais que tout cela fonctionne avec des cartes, mais je ne voulais pas avoir à spécifier tous les champs à chaque fois.

Je travaillais dans Ruby donc je ne peux pas vous donner l'implémentation PHP mais le principe devrait être le même.

J'ai défini un type scalaire personnalisé appelé JSON qui renvoie simplement un objet JSON littéral.

L'implémentation de ruby ​​était comme ça (en utilisant graphql-ruby)

module Graph
  module Types
    JsonType = GraphQL::ScalarType.define do
      name "JSON"
      coerce_input -> (x) { x }
      coerce_result -> (x) { x }
    end
  end
end

Puis je l'ai utilisé pour nos objets comme ça

field :location, Types::JsonType

J'utiliserais cela avec parcimonie, en l'utilisant uniquement là où vous savez que vous avez toujours besoin de tout l'objet JSON (comme je l'ai fait dans mon cas). Sinon, cela va à l'encontre de l'objet de GraphQL plus généralement.

Le format de requête GraphQL a été conçu pour permettre:

1. La forme de la requête et celle du résultat sont exactement les mêmes .
2. Le serveur connaît exactement les champs demandés, ainsi le client ne télécharge que les données essentielles.

Cependant, selon la documentation GraphQL , vous pouvez créer des fragments afin de rendre les jeux de sélection plus réutilisables:

# Only most used selection properties

fragment UserDetails on User {
    id,
    username
} 

Ensuite, vous pouvez interroger tous les détails de l'utilisateur en:

FetchUsers {
    users() {
        ...UserDetails
    }
}

Vous pouvez également ajouter des champs supplémentaires à côté de votre fragment :

FetchUserById($id: ID!) {
    users(id: $id) {
        ...UserDetails
        count
    }
}

Le package graphql-type-json prend en charge le type JSON de scalaires personnalisés. Utilisez-le pour afficher tout le champ de vos objets json. Voici le lien de l'exemple dans ApolloGraphql Server. https://www.apollographql.com/docs/apollo-server/schema/scalars-enums/#custom-scalars