Come interrogare tutti i campi di tipo GraphQL senza scrivere una lunga query?

Supponi di avere un tipo GraphQL e include molti campi. Come interrogare tutti i campi senza scrivere una lunga query che includa i nomi di tutti i campi?

Ad esempio, se ho questi campi:

 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'
            ]

        ];
    }

Per interrogare tutti i campi di solito la query è qualcosa del genere:

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

Ma voglio un modo per avere gli stessi risultati senza scrivere tutti i campi, qualcosa del genere:

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

C'è un modo per farlo in GraphQL?

Sto usando la libreria Folkloreatelier / laravel-graphql .

Purtroppo quello che vorresti fare non è possibile. GraphQL richiede che tu sia esplicito nello specificare quali campi desideri restituire dalla tua query.

Sì, puoi farlo usando l' introspezione . Crea una query GraphQL come (per tipo UserType )

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

e riceverai una risposta del tipo (i nomi dei campi effettivi dipenderanno dalla definizione dello schema / tipo effettivo)

{
  "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. ...)
      ]
    }
  }
}

È quindi possibile leggere questo elenco di campi nel client e creare dinamicamente una seconda query GraphQL per ottenere tutti questi campi.

Questo si basa sul fatto che tu conosca il nome del tipo per il quale desideri ottenere i campi: se non conosci il tipo, puoi riunire tutti i tipi e campi usando l'introspezione come

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

NOTA: questi sono i dati GraphQL over-the-wire: sei da solo per capire come leggere e scrivere con il tuo client effettivo. La tua libreria javascript graphQL potrebbe già utilizzare l'introspezione in qualche modo, ad esempio il comando apollo codegen utilizza l'introspezione per generare i tipi.

Immagino che l'unico modo per farlo sia utilizzando frammenti riutilizzabili:

fragment UserFragment on Users {
    id
    username
    count
} 

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

Ho affrontato lo stesso problema quando avevo bisogno di caricare i dati sulla posizione che avevo serializzato nel database dall'API di Google Places. Generalmente vorrei tutto in modo che funzioni con le mappe, ma non volevo specificare tutti i campi ogni volta.

Lavoravo in Ruby quindi non posso darti l'implementazione di PHP, ma il principio dovrebbe essere lo stesso.

Ho definito un tipo scalare personalizzato chiamato JSON che restituisce solo un oggetto JSON letterale.

L'implementazione di ruby ​​era così (usando graphql-ruby)

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

Poi l'ho usato per i nostri oggetti in questo modo

field :location, Types::JsonType

Lo userei con molta parsimonia, usandolo solo dove sai che hai sempre bisogno dell'intero oggetto JSON (come ho fatto nel mio caso). Altrimenti sta sconfiggendo l'oggetto di GraphQL più in generale.

Il formato di query GraphQL è stato progettato per consentire:

1. Sia la forma della query che quella del risultato sono esattamente le stesse .
2. Il server conosce esattamente i campi richiesti, quindi il client scarica solo i dati essenziali.

Tuttavia, secondo la documentazione di GraphQL , è possibile creare frammenti per rendere i set di selezione più riutilizzabili:

# Only most used selection properties

fragment UserDetails on User {
    id,
    username
} 

Quindi puoi interrogare tutti i dettagli dell'utente:

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

Puoi anche aggiungere campi aggiuntivi accanto al frammento :

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

Il pacchetto graphql-type-json supporta il tipo JSON con scalari personalizzati. Usalo può mostrare tutto il campo dei tuoi oggetti json. Ecco il collegamento dell'esempio in ApolloGraphql Server. https://www.apollographql.com/docs/apollo-server/schema/scalars-enums/#custom-scalars