Setting Up a Basic GraphQL Server in Laravel Using Rebing GraphQL

 

GraphQL has become increasingly popular for its flexibility and efficiency in API development. Unlike traditional REST APIs, GraphQL allows clients to request only the data they need, reducing over-fetching and under-fetching issues. In this article, we’ll walk through the process of setting up a basic GraphQL server in a Laravel application using the Rebing GraphQL package.

What is Rebing GraphQL?

Rebing GraphQL is a Laravel package that simplifies the implementation of a GraphQL server in your Laravel application. It provides all the tools needed to define your schema, queries, and mutations while integrating seamlessly with Laravel’s existing ecosystem.

Prerequisites

Before starting, make sure you have a working Laravel application set up. You should also have some familiarity with Laravel and GraphQL concepts.

Step 1: Install the Rebing GraphQL Package

First, you need to install the Rebing GraphQL package using Composer:

composer require rebing/graphql-laravel

After installation, publish the configuration file using the following command:

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

This will create a configuration file at `config/graphql.php`.

Step 2: Define the GraphQL Schema

The schema defines the structure of your API, including the types, queries, and mutations. In Rebing GraphQL, you define your schema in the `graphql.php` configuration file.

Let’s start by defining a simple query for fetching user data.

1. Create a User Model and Migration:

If you don’t already have a User model, you can create one with:

php artisan make:model User -m

In the migration file, define a simple users table:

Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email')->unique();
    $table->timestamps();
});

Run the migration:

php artisan migrate

2. Create a User Type:

In GraphQL, a “type” represents an object or entity that can be queried. For this example, create a `UserType` class:

php artisan make:graphql:type UserType

In the generated `UserType` class, define the fields that will be exposed by the GraphQL API:

namespace App\GraphQL\Types;

use Rebing\GraphQL\Support\Type as GraphQLType;
use GraphQL\Type\Definition\Type;
use App\Models\User;

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'
            ],
        ];
    }
}

3. Create a Query:

Queries are used to fetch data. Let’s create a `UserQuery` class:

php artisan make:graphql:query UserQuery

In the `UserQuery` class, define how to fetch the data:

namespace App\GraphQL\Queries;

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

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

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

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

4. Register the Type and Query:

In the `config/graphql.php` file, register the `UserType` and `UserQuery`:

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

'schemas' => [
    'default' => [
        'query' => [
            'users' => App\GraphQL\Queries\UserQuery::class,
        ],
    ],
],

Step 3: Test the GraphQL API

Start the Laravel development server:

php artisan serve

You can now access the GraphQL endpoint at `http://localhost:8000/graphql`. You can use a tool like GraphiQL or Postman to test the API.

Here’s an example query:

{
  users {
    id
    name
    email
  }
}

This query will return a list of users with their ID, name, and email.

Step 4: Adding Mutations (Optional)

In addition to queries, GraphQL allows you to perform mutations (create, update, delete operations). You can create a mutation class using:

php artisan make:graphql:mutation CreateUserMutation

Define your mutation logic in the generated class and register it in the `config/graphql.php` file under the `mutations` array.

Step 5: Securing the GraphQL Endpoint

Just like with REST, you need to secure your GraphQL endpoint. You can apply middleware to your queries and mutations for authentication and authorization:

'query' => [
    'users' => App\GraphQL\Queries\UserQuery::class,
],

'middleware' => ['auth:api'],

This ensures that only authenticated users can access specific queries or mutations.

Setting up a GraphQL server in Laravel using Rebing GraphQL is straightforward and provides a lot of flexibility compared to traditional REST APIs. With just a few steps, you can define types, queries, and mutations that allow your clients to fetch exactly the data they need. As your application grows, GraphQL’s strongly typed schema and single endpoint approach can simplify API management while improving performance and efficiency.