Installing and Configuring a Laravel GraphQL Package


GraphQL is a powerful query language for APIs and a runtime to execute queries by specifying the structure of data that you want from the server. It allows for more efficient and flexible data fetching compared to traditional REST APIs. In Laravel, using GraphQL is made simpler with various packages, such as the Rebing GraphQL package. This article will guide you through the installation and configuration of a GraphQL package in a Laravel application.


Why Use GraphQL in Laravel?


GraphQL is highly beneficial when working with modern applications, especially single-page apps (SPAs), mobile apps, or any situation where you need to minimize network requests and fetch data more efficiently. Laravel, with its robust ecosystem, provides easy integration with GraphQL through packages like Rebing GraphQL.


Step-by-Step Guide to Installing and Configuring a GraphQL Package in Laravel


1. Prerequisites


Before you start, ensure you have the following:


  • A Laravel application installed. If you haven't installed Laravel yet, you can create a new Laravel project using:

  composer create-project --prefer-dist laravel/laravel graphql-demo

  • PHP 7.4 or higher.
  • Composer installed.


2. Installing the Rebing GraphQL Package


The Rebing GraphQL package is a widely-used package that integrates GraphQL into Laravel seamlessly. You can install it using Composer:


composer require rebing/graphql-laravel


Once the package is installed, you need to publish the configuration file:


php artisan vendor:publish --provider="Rebing\GraphQL\GraphQLServiceProvider"


This will create a `graphql.php` file in your Laravel application's `config` folder, where you can define settings related to GraphQL schema, queries, and mutations.


3. Configuring the GraphQL Package


The configuration file `graphql.php` defines various aspects of how GraphQL will operate within your Laravel application.


Open `config/graphql.php` and you will see several sections, including:


Schemas: Defines different schemas for your API.

Types: Allows you to define reusable GraphQL types.

Middleware: You can apply custom middleware for authentication or authorization.


Here’s an example configuration for your first schema:


return [
    'schema' => [
        'default' => [
            'query' => [
                'user' => App\GraphQL\Queries\UserQuery::class,
            ],
            'mutation' => [
                'createUser' => App\GraphQL\Mutations\CreateUserMutation::class,
            ],
            'middleware' => ['auth:api'],
        ],
    ],
];


4. Defining Queries and Mutations


Defining a Query


First, create a folder in your Laravel app called `GraphQL`. Inside this folder, create another folder called `Queries`.


Now, define your first query by creating a file called `UserQuery.php` inside `app/GraphQL/Queries/`:


namespace App\GraphQL\Queries;

use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Query;
use App\Models\User;

class UserQuery extends Query
{
    protected $attributes = [
        'name' => 'user',
    ];

    public function type(): Type
    {
        return Type::listOf(\GraphQL::type('User'));
    }

    public function resolve($root, $args)
    {
        return User::all();
    }
}


This query will fetch all users from the database.


Defining a Mutation


Next, create a mutation inside `app/GraphQL/Mutations/CreateUserMutation.php`:


namespace App\GraphQL\Mutations;

use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Mutation;
use App\Models\User;

class CreateUserMutation extends Mutation
{
    protected $attributes = [
        'name' => 'createUser',
    ];

    public function type(): Type
    {
        return \GraphQL::type('User');
    }

    public function args(): array
    {
        return [
            'name' => ['type' => Type::string()],
            'email' => ['type' => Type::string()],
        ];
    }

    public function resolve($root, $args)
    {
        return User::create([
            'name' => $args['name'],
            'email' => $args['email'],
        ]);
    }
}


This mutation will allow you to create new users.


5. Defining GraphQL Types


In GraphQL, types define the shape of the data you can query or mutate. To define a user type, create a new file in `app/GraphQL/Types/UserType.php`:


namespace App\GraphQL\Types;

use Rebing\GraphQL\Support\Type as GraphQLType;
use GraphQL\Type\Definition\Type;

class UserType extends GraphQLType
{
    protected $attributes = [
        'name' => 'User',
        'description' => 'A user type',
    ];

    public function fields(): array
    {
        return [
            'id' => [
                'type' => Type::nonNull(Type::int()),
                'description' => 'The id of the user',
            ],
            'name' => [
                'type' => Type::string(),
                'description' => 'The name of the user',
            ],
            'email' => [
                'type' => Type::string(),
                'description' => 'The email of the user',
            ],
        ];
    }
}


6. Registering the Type


Finally, register the `UserType` in the `graphql.php` configuration file:


'types' => [
    'User' => App\GraphQL\Types\UserType::class,
],


7. Testing the GraphQL API


With the setup complete, you can now test your GraphQL API using a tool like GraphiQL. You can use routes like `/graphql` to interact with your queries and mutations.


For example, to fetch users, you can use the following query:


{
    user {
        id
        name
        email
    }
}


And to create a new user, you can run this mutation:


mutation {
  createUser(name: "John Doe", email: "john@example.com") {
    id
    name
    email
  }
}



By installing and configuring a GraphQL package like Rebing in Laravel, you can quickly set up a robust GraphQL API. This allows for efficient and flexible data fetching, improving the performance and user experience of your applications. Following the steps outlined in this article will get you up and running with GraphQL in no time.


Stay tuned for more advanced GraphQL topics like pagination, authorization, and error handling in Laravel!