laravel graphql
1.0.0
Use Facebook GraphQL com Laravel 5 ou Lumen. É baseado na implementação do PHP aqui. Você pode encontrar mais informações sobre GraphQL na Introdução ao GraphQL no blog React ou pode ler as especificações do GraphQL. Este é um trabalho em andamento.
Este pacote é compatível com o modelo Eloquent (ou qualquer outra fonte de dados). Veja o exemplo abaixo.
A versão 1.0 é lançada. Se você estiver atualizando de uma versão mais antiga, poderá marcar Atualizar para 1.0.
1- Solicite o pacote via Composer no seu composer.json .
{
"require" : {
"folklore/graphql" : " ~1.0.0 "
}
}2- Execute o Composer para instalar ou atualizar o novo requisito.
$ composer installou
$ composer update1- Publique o arquivo de configuração
$ php artisan vendor:publish --provider= " FolkloreGraphQLServiceProvider "2- Revise o arquivo de configuração
config/graphql.php
1- Adicione o provedor de serviços ao seu arquivo config/app.php
Folklore GraphQL ServiceProvider::class, 2- Adicione a fachada ao seu arquivo config/app.php
' GraphQL ' => Folklore GraphQL Support Facades GraphQL::class,3- Publique o arquivo de configuração
$ php artisan vendor:publish --provider= " FolkloreGraphQLServiceProvider "4- Revise o arquivo de configuração
config/graphql.php
1- Carregue o provedor de serviços em bootstrap/app.php
$ app -> register ( Folklore GraphQL LumenServiceProvider::class); 2- Para utilizar a fachada você deve descomentar a linha $app->withFacades(); em bootstrap/app.php
Após descomentar esta linha você terá a fachada GraphQL habilitada
$ app -> withFacades ();3- Publique o arquivo de configuração
$ php artisan graphql:publish 4- Carregue o arquivo de configuração em bootstrap/app.php
Importante : este comando precisa ser executado antes do cadastro do prestador de serviço
$ app -> configure ( ' graphql ' );
. . .
$ app -> register ( Folklore GraphQL LumenServiceProvider::class)5- Revise o arquivo de configuração
config/graphql.php
A partir da versão 1.0, você pode definir vários esquemas. Ter vários esquemas pode ser útil se, por exemplo, você quiser um endpoint que seja público e outro que precise de autenticação.
Você pode definir vários esquemas na configuração:
' schema ' => ' default ' ,
' schemas ' => [
' default ' => [
' query ' => [
// 'users' = > 'AppGraphQLQueryUsersQuery'
],
' mutation ' => [
// 'updateUserEmail' = > 'AppGraphQLQueryUpdateUserEmailMutation'
]
],
' secret ' => [
' query ' => [
// 'users' = > 'AppGraphQLQueryUsersQuery'
],
' mutation ' => [
// 'updateUserEmail' = > 'AppGraphQLQueryUpdateUserEmailMutation'
]
]
]Ou você pode adicionar esquema usando a fachada:
GraphQL:: addSchema ( ' secret ' , [
' query ' => [
' users ' => ' AppGraphQLQueryUsersQuery '
],
' mutation ' => [
' updateUserEmail ' => ' AppGraphQLQueryUpdateUserEmailMutation '
]
]);Depois, você pode construir o esquema usando a fachada:
// Will return the default schema defined by 'schema' in the config
$ schema = GraphQL:: schema ();
// Will return the 'secret' schema
$ schema = GraphQL:: schema ( ' secret ' );
// Will build a new schema
$ schema = GraphQL:: schema ([
' query ' => [
// 'users' = > 'AppGraphQLQueryUsersQuery'
],
' mutation ' => [
// 'updateUserEmail' = > 'AppGraphQLQueryUpdateUserEmailMutation'
]
]);Ou você pode solicitar o endpoint para um esquema específico
// Default schema
http://homestead.app/graphql?query=query+FetchUsers{users{id,email}}
// Secret schema
http://homestead.app/graphql/secret?query=query+FetchUsers{users{id,email}}
Primeiro você precisa criar um tipo.
namespace App GraphQL Type ;
use GraphQL Type Definition Type ;
use Folklore GraphQL Support Type as GraphQLType ;
class UserType extends GraphQLType
{
protected $ attributes = [
' name ' => ' User ' ,
' description ' => ' A user '
];
/ *
* Uncomment following line to make the type input object .
* http : // graphql . org / learn / schema / #input-types
* /
// protected $ inputObject = true ;
public function fields ()
{
return [
' id ' => [
' type ' => Type:: nonNull (Type:: string ()),
' description ' => ' The id of the user '
],
' email ' => [
' type ' => Type:: string (),
' description ' => ' The email of user '
]
];
}
// If you want to resolve the field yourself , you can declare a method
// with the following format resolve [ FIELD_NAME ] Field ()
protected function resolveEmailField ( $ root , $ args )
{
return strtolower ( $ root -> email );
}
} Adicione o tipo ao arquivo de configuração config/graphql.php
' types ' => [
' User ' => ' AppGraphQLTypeUserType '
] Você também pode adicionar o tipo com o GraphQL Façade, em um provedor de serviços, por exemplo.
GraphQL:: addType ( ' AppGraphQLTypeUserType ' , ' User ' );Então você precisa definir uma consulta que retorne esse tipo (ou uma lista). Você também pode especificar argumentos que podem ser usados no método resolve.
namespace App GraphQL Query ;
use GraphQL ;
use GraphQL Type Definition Type ;
use Folklore GraphQL Support Query ;
use App User ;
class UsersQuery extends Query
{
protected $ attributes = [
' name ' => ' users '
];
public function type ()
{
return Type:: listOf (GraphQL:: type ( ' User ' ));
}
public function args ()
{
return [
' id ' => [ ' name ' => ' id ' , ' type ' => Type:: string ()],
' email ' => [ ' name ' => ' email ' , ' type ' => Type:: string ()]
];
}
public function resolve ( $ root , $ args )
{
if ( isset ( $ args [ ' id ' ])) {
return User:: where ( ' id ' , $ args [ ' id ' ])-> get ();
} else if ( isset ( $ args [ ' email ' ])) {
return User:: where ( ' email ' , $ args [ ' email ' ])-> get ();
} else {
return User:: all ();
}
}
} Adicione a consulta ao arquivo de configuração config/graphql.php
' schemas ' => [
' default ' => [
' query ' => [
' users ' => ' AppGraphQLQueryUsersQuery '
],
// ...
]
] E é isso. Você deve ser capaz de consultar o GraphQL com uma solicitação para o URL /graphql (ou qualquer coisa que você escolher em sua configuração). Experimente uma solicitação GET com a seguinte entrada query
query FetchUsers {
users {
id
email
}
}
Por exemplo, se você usar propriedade:
http://homestead.app/graphql?query=query+FetchUsers{users{id,email}}
Uma mutação é como qualquer outra consulta, ela aceita argumentos (que serão usados para fazer a mutação) e retorna um objeto de um determinado tipo.
Por exemplo, uma mutação para atualizar a senha de um usuário. Primeiro você precisa definir a Mutação.
namespace App GraphQL Mutation ;
use GraphQL ;
use GraphQL Type Definition Type ;
use Folklore GraphQL Support Mutation ;
use App User ;
class UpdateUserPasswordMutation extends Mutation
{
protected $ attributes = [
' name ' => ' updateUserPassword '
];
public function type ()
{
return GraphQL:: type ( ' User ' );
}
public function args ()
{
return [
' id ' => [ ' name ' => ' id ' , ' type ' => Type:: nonNull (Type:: string ())],
' password ' => [ ' name ' => ' password ' , ' type ' => Type:: nonNull (Type:: string ())]
];
}
public function resolve ( $ root , $ args )
{
$ user = User:: find ( $ args [ ' id ' ]);
if (! $ user ) {
return null ;
}
$ user -> password = bcrypt ( $ args [ ' password ' ]);
$ user -> save ();
return $ user ;
}
} Como você pode ver no método resolve , você usa os argumentos para atualizar seu modelo e retorná-lo.
Em seguida, você adiciona a mutação ao arquivo de configuração config/graphql.php
' schema ' => [
' default ' => [
' mutation ' => [
' updateUserPassword ' => ' AppGraphQLMutationUpdateUserPasswordMutation '
],
// ...
]
]Você poderá então usar a seguinte consulta em seu endpoint para fazer a mutação.
mutation users {
updateUserPassword(id: "1", password: "newpassword") {
id
email
}
}
se você usar homestead:
http://homestead.app/graphql?query=mutation+users{updateUserPassword(id: "1", password: "newpassword"){id,email}}
É possível adicionar regras de validação à mutação. Ele usa o Validator laravel para realizar a validação em relação aos args .
Ao criar uma mutação, você pode adicionar um método para definir as regras de validação aplicáveis fazendo o seguinte:
namespace App GraphQL Mutation ;
use GraphQL ;
use GraphQL Type Definition Type ;
use Folklore GraphQL Support Mutation ;
use App User ;
class UpdateUserEmailMutation extends Mutation
{
protected $ attributes = [
' name ' => ' UpdateUserEmail '
];
public function type ()
{
return GraphQL:: type ( ' User ' );
}
public function args ()
{
return [
' id ' => [ ' name ' => ' id ' , ' type ' => Type:: string ()],
' email ' => [ ' name ' => ' email ' , ' type ' => Type:: string ()]
];
}
public function rules ()
{
return [
' id ' => [ ' required ' ],
' email ' => [ ' required ' , ' email ' ]
];
}
public function resolve ( $ root , $ args )
{
$ user = User:: find ( $ args [ ' id ' ]);
if (! $ user ) {
return null ;
}
$ user -> email = $ args [ ' email ' ];
$ user -> save ();
return $ user ;
}
}Alternativamente, você pode definir regras com cada argumento
class UpdateUserEmailMutation extends Mutation
{
// ...
public function args ()
{
return [
' id ' => [
' name ' => ' id ' ,
' type ' => Type:: string (),
' rules ' => [ ' required ' ]
],
' email ' => [
' name ' => ' email ' ,
' type ' => Type:: string (),
' rules ' => [ ' required ' , ' email ' ]
]
];
}
// ...
} Quando você executa uma mutação, ela retorna os erros de validação. Como as especificações do GraphQL definem um determinado formato para erros, as mensagens de erros de validação são adicionadas ao objeto de erro como um atributo validation extra. Para encontrar o erro de validação, você deve verificar o erro com uma message igual a 'validation' , então o atributo validation conterá as mensagens de erros normais retornadas pelo Validador Laravel.
{
"data" : {
"updateUserEmail" : null
},
"errors" : [
{
"message" : " validation " ,
"locations" : [
{
"line" : 1 ,
"column" : 20
}
],
"validation" : {
"email" : [
" The email is invalid. "
]
}
}
]
}
