Como consultar todos os campos do tipo GraphQL sem escrever uma consulta longa?

Suponha que você tenha um tipo GraphQL e ele inclui muitos campos. Como consultar todos os campos sem anotar uma consulta longa que inclua os nomes de todos os campos?

Por exemplo, se eu tiver estes campos:

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

        ];
    }

Para consultar todos os campos, geralmente a consulta é algo como isto:

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

Mas eu quero uma maneira de obter os mesmos resultados sem escrever todos os campos, algo como isto:

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

Existe uma maneira de fazer isso no GraphQL?

Estou usando a biblioteca Folkloreatelier / laravel-graphql .

Infelizmente, o que você gostaria de fazer não é possível. O GraphQL exige que você seja explícito sobre a especificação de quais campos você gostaria que retornassem da sua consulta.

Sim, você pode fazer isso usando a introspecção . Faça uma consulta GraphQL como (para o tipo UserType )

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

e você receberá uma resposta como (os nomes reais dos campos dependerão da sua definição real de esquema / tipo)

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

Você pode então ler esta lista de campos em seu cliente e criar dinamicamente uma segunda consulta GraphQL para obter todos esses campos.

Isso depende de você saber o nome do tipo para o qual deseja obter os campos - se você não souber o tipo, poderá reunir todos os tipos e campos usando a introspecção, como

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

OBSERVAÇÃO: esses são os dados do GraphQL sem fio - você está sozinho para descobrir como ler e escrever com o seu cliente real. Sua biblioteca javascript graphQL já pode empregar introspecção em alguma capacidade, por exemplo, o comando apollo codegen usa introspecção para gerar tipos.

Eu acho que a única maneira de fazer isso é utilizando fragmentos reutilizáveis:

fragment UserFragment on Users {
    id
    username
    count
} 

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

Eu enfrentei esse mesmo problema quando precisei carregar os dados de localização serializados no banco de dados a partir da API do Google Places. Geralmente, eu gostaria da coisa toda, para que funcionasse com mapas, mas não queria especificar todos os campos todas as vezes.

Eu estava trabalhando em Ruby, então não posso fornecer a implementação do PHP, mas o princípio deve ser o mesmo.

Eu defini um tipo escalar personalizado chamado JSON que apenas retorna um objeto JSON literal.

A implementação do ruby ​​foi assim (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

Então eu usei para nossos objetos assim

field :location, Types::JsonType

Eu usaria isso com moderação, usando-o apenas onde você sabe que sempre precisa de todo o objeto JSON (como eu fiz no meu caso). Caso contrário, ele está derrotando o objeto do GraphQL de maneira mais geral.

O formato de consulta GraphQL foi projetado para permitir:

1. As formas de consulta e resultado são exatamente iguais .
2. O servidor conhece exatamente os campos solicitados, portanto, o cliente baixa apenas os dados essenciais.

No entanto, de acordo com a documentação do GraphQL , você pode criar fragmentos para tornar os conjuntos de seleção mais reutilizáveis:

# Only most used selection properties

fragment UserDetails on User {
    id,
    username
} 

Em seguida, você pode consultar todos os detalhes do usuário:

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

Você também pode adicionar campos adicionais ao lado do seu fragmento :

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

O pacote graphql-type-json suporta escalonadores personalizados do tipo JSON. Use-o para mostrar todo o campo de seus objetos json. Aqui está o link do exemplo no ApolloGraphql Server. https://www.apollographql.com/docs/apollo-server/schema/scalars-enums/#custom-scalars