Install Lighthouse via Composer using composer require nuwave/lighthouse. 2. Publish configuration and schema files with php artisan vendor:publish --provider="Nuwave\Lighthouse\LighthouseServiceProvider". 3. Define your GraphQL schema in graphql/schema.graphql using types, queries, and mutations with Lighthouse directives like @all and @find. 4. Set up the Post model and migration using php artisan make:model Post -m, run migration, and ensure fillable attributes are set. 5. Test the GraphQL endpoint at /graphql by sending queries or using the built-in IDE in development. 6. Customize logic with resolvers by updating the schema to use @field(resolver: "Post@posts") and creating a resolver class in app/GraphQL/Queries/Post.php. 7. Add authentication and authorization using directives like @guard and @can on queries and mutations. 8. Apply input validation with the @rules directive to enforce constraints like required or min:3. 9. Optimize performance by leveraging Lighthouse’s built-in DataLoader to resolve relationships such as @hasMany and avoid N 1 queries. 10. Secure the API in production by disabling the GraphQL IDE, adding rate limiting, enabling persisted queries, and configuring caching as needed. Using Lighthouse allows seamless integration of a full-featured, secure, and efficient GraphQL API into Laravel using schema-first design and native Eloquent integration.

Implementing GraphQL in a Laravel application can greatly enhance how your frontend consumes data, especially when you want flexible, efficient queries. While Laravel doesn’t include GraphQL support out of the box (unlike REST), you can integrate it smoothly using packages. The most popular and well-maintained package for this is Lighthouse by Nuwave.

Here’s a step-by-step guide to get GraphQL working in your Laravel app.

? 1. Install Lighthouse via Composer

Start by installing the Lighthouse package:

composer require nuwave/lighthouse

Lighthouse is a powerful GraphQL server implementation for Laravel that uses schema-first design and leverages Laravel’s features.

? 2. Publish Configuration and Schema

Run the vendor publish command to get the config and default schema:

php artisan vendor:publish --provider="Nuwave\Lighthouse\LighthouseServiceProvider"

This creates:

• config/lighthouse.php – configuration file
• routes/graphql.php – GraphQL route
• app/GraphQL directory (if not present)
• graphql/schema.graphql – your main schema file

? 3. Define Your GraphQL Schema

Open graphql/schema.graphql. This is where you define types, queries, mutations, etc.

For example, let’s assume you have a Post model. Define a basic schema:

type Post {
    id: ID!
    title: String!
    content: String
    created_at: DateTime!
}

type Query {
    posts: [Post!]! @all
    post(id: ID! @eq): Post @find
}

type Mutation {
    createPost(title: String!, content: String!): Post @create
    updatePost(id: ID!, title: String, content: String): Post @update
    deletePost(id: ID!): Post @delete
}

? Note: Directives like @all, @find, @create, @update, @delete are built-in Lighthouse directives that map to Eloquent operations.

? 4. Set Up the Model and Migration (if needed)

Make sure your Post model exists and the database table is set up:

php artisan make:model Post -m

Update the migration and run:

php artisan migrate

Ensure your model is set up correctly:

// app/Models/Post.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $fillable = ['title', 'content'];
}

?? Don’t forget to update config/lighthouse.php if you're using custom model namespaces.

? 5. Test the GraphQL Endpoint

Lighthouse sets up a route at /graphql by default (defined in routes/graphql.php).

You can now send POST requests to /graphql with queries like:

query {
  posts {
    id
    title
    content
    created_at
  }
}

Or use the built-in GraphQL IDE (if enabled):

• Visit: http://your-app.test/graphql (only in local/dev by default)
• This opens GraphiQL or Altair, where you can test queries.

? In production, make sure to disable the GraphQL IDE for security.

? 6. Customize with Resolvers (Optional)

If you need custom logic (e.g., filtering, permissions, complex data), create a resolver.

For example, customize the posts query:

Update schema:

type Query {
    posts(search: String): [Post!]! @field(resolver: "Post@posts")
}

Create a resolver class:

// app/GraphQL/Queries/Post.php
namespace App\GraphQL\Queries;

class Post
{
    public function posts($_, array $args)
    {
        $query = \App\Models\Post::query();

        if (isset($args['search'])) {
            $query->where('title', 'LIKE', '%' . $args['search'] . '%');
        }

        return $query->get();
    }
}

? 7. Authentication & Authorization

To protect queries/mutations, use Lighthouse directives like @guard or @can.

Example:

type Mutation {
    createPost(title: String!, content: String!): Post @create @guard
}

This ensures the user is authenticated.

For policies:

deletePost(id: ID!): Post @delete @can(ability: "delete", model: "App\\Models\\Post")

? 8. Validation

Use the @rules directive to validate inputs:

createPost(
    title: String! @rules(apply: ["required", "min:3"])
    content: String @rules(apply: ["max:1000"])
): Post @create

? 9. Optimize with DataLoader (Avoid N 1)

Lighthouse supports DataLoader out of the box for resolving relationships efficiently.

For example, if a Post has many Comments, define the relationship in Eloquent, then use @hasMany in the schema:

type Post {
    id: ID!
    title: String!
    comments: [Comment!]! @hasMany
}

Lighthouse will automatically batch-load comments.

? 10. Deploy & Secure

Before going live:

• Disable GraphQL IDE in production (lighthouse.php → 'route' => ['middleware' => ['your-middleware']])
• Add rate limiting
• Use persisted queries in production (optional)
• Enable caching if needed

Summary

Using Lighthouse is the cleanest way to add GraphQL to Laravel. It lets you:

• Define schema in .graphql files
• Use Eloquent directly via directives
• Extend with custom resolvers
• Secure with Laravel’s auth system

With this setup, you get a full-featured GraphQL API that feels native to Laravel.

Basically, just install Lighthouse, define your schema, and go.

The above is the detailed content of How to implement GraphQL in a Laravel application?. For more information, please follow other related articles on the PHP Chinese website!