GraphQL is the language of APIs and can be used to fetch data from a server...

GraphQL server creation using Laravel is made simple. Build a query for your data, learn tricky moves and improve your efficiency with this insightful article.

Setting A GraphQL Server Using Laravel

Setting up a GraphQL Server Using Laravel

It is quite easy to start with GraphQL. You need to put a Laravel0 environment in the terminal and run this command.

composer create-project laravel/laravel graphql-laravel


Next, you need to install the GraphQL Llaravel package by running the configuration below:

Once you are done with the installation, you need to update the following code:

config/graphql.php

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


Getting started with GraphQL

You need to build and explain the models where you will demarcate the relationship between the entities. You will also define the new database schemas and create new migrations.

To do so, you need to create a ‘hasMany’ relationship between the posts and the users.

public function user()
{
	return $this->belongsTo(User::class);
}


Creating migration, resources & controllers

Laravel offers a useful default migration. You simply need to add a new migration for new posts by running the following command:

php artisan make:migration create_post_table


Running the above code creates a new migration in the ‘database/migrations’. Next you need to define the schema in the migration file:

Schema::create('posts', function (Blueprint $table) {
            $table->id();
             $table->integer('user_id')->unsigned();
            $table->string('title');
            $table->text('comment');
            $table->timestamps();
        });


Next, you have to revise the existing ‘.env’ file to define your database. The code below will help you establish a new connection.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=graphql-laravel
DB_USERNAME=root
DB_PASSWORD=


Now you need to migrate the command to create new Users and Post tables.

Creating a new migration

Run the following code to build a new post:

After creating a new file within the ‘database>factories’ directory, you need to define the column names and other elements you want to have within the definition. Here is the code to do the same:

use Illuminate\Support\Str;


public function definition()
    {
        return [
            'user_id' => rand(1,5),
            'title' => $this->faker->name(),
            'comment' => $this->faker->realText(180)
        ];
    }


Creating a new post

You can create a new execution instance for both the Posts and User factories within the seeder class.

The code given below creates 7 posts and 7 users with their corresponding IDs:

public function run()
    {
        \App\Models\User::factory(7)->create();

        \App\Models\Post::factory(7)->create();
    }


After running the above code, you need to artisan seeder command:

Creating a new database seeder

Here is the code to create a new user query:

<?php

namespace App\GraphQL\Type;

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

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

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


In the above code fragment, you need to have the namespace to the specific User model. You also need to have a protected $attributes array that will describe the particular User model. Apart from that, you also need to have a public field function that returns the $attributes array. You have to define the schema that includes the columns within this public field function.

Creating a new user query

Use the code fragment given below to add a new UserType to the configuration you created previously:

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


Adding a type to the configuration

After adding a type to the configuration, you need to define a query that returns a list. On top of that, you also need to specify all the arguments you want to include within the method.

Here is the code to define a new user query:

<?php

namespace App\GraphQL\Type;

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

class UserType extends GraphQLType
{
    protected $attributes = [
        'name'          => 'User',
        'description'   => 'A user',
        'model'         => User::class,
    ];
    
    public function type(): Type
    {
        return Type::nonNull(Type::listOf(Type::nonNull(GraphQL::type('User'))));
    }

    public function args(): array
    {
        return [
            'id' => [
                'type' => Type::nonNull(Type::int()),
                'description' => 'The id of the user',
            ],
            'name' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The name of user',
            ],
            'email' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The email of user',
            ]
        ];
    }
    
    public function resolve($root, $args)
    {        
        if (isset($args['id'])) {
            return User::whereId($args['id'])->get();
        }
        
        if (isset($args['name'])) {
            return User::whereName($args['name'])->get();
        }

        if (isset($args['email'])) {
            return User::whereEmail($args['email'])->get();
        }

        return User::all();
    }
}


In the code fragment above, we have used the required namespace with ‘ App\Models\User’. We have also defined the attributes and extended the GraphQLType.

The method we have used here fetches the data from the database. If there are any arguments then the ‘if’ block gets executed.

Defining a new user query

Moving ahead, you need to add the given query to the following configuration file:

app > config > graphql.php

'schemas' => [
        'default' => [
            'query' => [
                App\GraphQL\Query\UsersQuery::class,
            ],
            'mutation' => [
                // ExampleMutation::class,
            ],
            'types' => [
                // ExampleType::class,
            ],
            'middleware' => [],
            'method' => ['get', 'post'],
        ],
    ],


Adding a query to the configuration

Below is the code to fetch all the users using a query:

query {
    users {
        id, name , email
    }
}


How to fetch all users using a query

To create a Post Relationship with the user, you need to define a PostType. The approach is very similar to that of UserType. To do so, you need to navigate to:
app > Type > PostType.php file and add the following:

<?php

namespace App\GraphQL\Type;

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

class PostType extends GraphQLType
{
    protected $attributes = [
        'name'          => 'Post',
        'description'   => 'A post',
        'model'         => Post::class,
    ];

    public function args(): array
    {
        return [
            'id' => [
                'type' => Type::nonNull(Type::int()),
                'description' => 'The id of the post',
            ],
            'title' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The title of post',
            ],
        ];
    }
}


The above code helps you extend the Query to the PostQuery class and protects the $attributes array. Apart from that you also have a field’s function that returns the array with the basic attributes including the comment, ID, and title.

Furthermore, you also have a type within the ‘args’ function that displays various types of data along with a description.

Creating a post-relationship with the user

To create a PostsQuery, all you need to do is to add the following code to ‘app > GraphQL > Query > PostsQuery.php’:

<?php 

namespace App\GraphQL\Query;

use Closure;
use App\Models\Post;
use Rebing\GraphQL\Support\Facades\GraphQL;
use GraphQL\Type\Definition\ResolveInfo;
use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Query;

class PostsQuery extends Query
{
    protected $attributes = [
        'name' => 'posts',
    ];

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

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

    public function resolve($root, $args)
    {        
        if (isset($args['id'])) {
            return Post::whereId($args['id'])->get();
        }
        
        if (isset($args['title'])) {
            return Post::whereTitle($args['title'])->get();
        }

        return Post::all();
    }
}


If there are any arguments, then the ‘if’ block gets executed. This helps you filter every field based on the user requests.

Creating a PostsQuery

This is the final phase of setting up a GraphQL server. In this step, you will see how to set a new mutation. This new mutation will help us with the operations that involve modifying the server state.

To create a new mutation folder within ‘app > Mutation > CreateUserMutation.php’, add the following code to the ‘CreateUserMutation.php’ file.

<?php

namespace App\GraphQL\Mutation;

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

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

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

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

    public function resolve($root, $args, $context, ResolveInfo $resolveInfo, Closure $getSelectFields)
    {
        return User::firstOrCreate(
            [   'email' => $args['email']],
            [   'name' => $args['name'],
                'password' => bcrypt($args['password'])
            ]);
    }
}


The resolve method helps the application users to sign up and create their own records. This approach accepts Argos as a parameter and uses the ‘firstOrCreate’ methodology to ensure that all users have a unique identifier.

We have made use of multiple built-in schemas, and created mutations, middleware, and custom queries. With Lighthouse, you can create your own customized schemas but we have limited our work to build the GraphQL server. The next time you want to set up an API for a single-page application, you can consider GraphQL to deal with your data query.

Creating a mutation

GraphQL is the language of APIs and can be used to fetch data from a server. This language also allows the clients to specify the exact data that is needed. It is a powerful query language used to interact with your API. As compared to the alternative architectures, such as the REST, GraphQL provides additional benefits.

Apart from the benefits, it also serves as an endpoint for mobile and single-page websites and applications. This language enables you to query the related and nested data and streamline the single round trip to the server.

Although the GraphQL community has grown immensely, the availability of documentation on how to use this technology is very little. In this article, we will learn how to create a GraphQL server using the Laravel framework along with some examples, mutations, query relationships, and authentications.

Yes. Laravel allows the developers to set up a GraphQL server and also offers complete flexibility to customize the same to address the different project requirements.

Setting up and implementing a GraphQl server is pretty straightforward. Follow these steps:

Firstly, you need to select a framework like Laravel to implement your GraphQL server.

After that, you need to define a schema that will allow your framework to route the incoming requests and queries.

You should create multiple Resolver functions that tell the framework what to return and what type of queries to handle.

Finally, you need to define a client-side query that retrieves the required data.

YES & NO as that depends on the requirement. GraphQL is a query language with runtime for addressing the queries with the existing data. GraphQL offers a complete description of the data in the API. Apart from that, it also enables your clients to have what they need and offers you powerful developer tools.

If you are working on the client-side then you do not need any server.

Yes. The graphql-php is a feature using which you can implement GraphQL in PHP. This graphql-php feature converts the GraphQL query to a PHP array. This is done with the help of the resolve function in every field.

GraphQL server is a powerful server-side implementation that exposes your data as the GraphQL API that helps your client apps to send requests for the data. These client applications can be mobile applications, single-page websites, or anything.

Frequently Asked Questions

What’s up with Turing?
Get the latest news about us here.

Press

Know more about remote work.
Checkout our blog here.

Blog

Have any questions?
We’d love to hear from you.

FOR DEVELOPERS

Setting up a GraphQL Server Using Laravel

Author

Jay Galiyal

How to Create a RESTful API Using the Flask Framework?

How to Implement User Authentication in a REST API Using Laravel Passport?

How to Make Navigation and Routing Possible in Angular 8?

A Guide to Content-Based Filtering In Recommender Systems

How to Make a Simplified Multilayer Perceptron in TensorFlow

Frequently Asked Questions

Press

Blog

Contact

Hire remote developers