CheatSheetsHero

Catalog / Laravel Lumen Cheat Sheet

Laravel Lumen Cheat Sheet

A concise cheat sheet for Laravel Lumen, covering essential commands, configurations, and functionalities to help you build microservices and APIs efficiently.

Getting Started

Installation

Install Lumen via Composer:

composer create-project --prefer-dist laravel/lumen <project-name>

Navigate to your project directory:

cd <project-name>

Run the local development server:

php -S localhost:8000 -t public

Basic Configuration

.env file:

Configure environment-specific settings, such as database connections and API keys. Example:

APP_DEBUG=true
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=lumen_db
DB_USERNAME=homestead
DB_PASSWORD=secret

bootstrap/app.php:

Configure middleware, service providers, and exception handling.

$app->withFacades();
$app->register(App\Providers\AppServiceProvider::class);

Enable Facades:

Uncomment $app->withFacades(); to enable facades.

$app->withFacades();

Enable Eloquent:

Uncomment $app->withEloquent(); to enable Eloquent ORM.

$app->withEloquent();

Routing

Define routes in routes/web.php or routes/api.php.

Example:

$router->get('/', function () { return 'Hello, Lumen!'; });

Available HTTP methods: get, post, put, patch, delete, options.

Route parameters:

$router->get('/user/{id}', function ($id) { return 'User ID: ' . $id; });

Controllers & Middleware

Controllers

Generate a controller:

php artisan make:controller <ControllerName>

Example Controller:

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class UserController extends Controller
{
    public function show($id)
    {
        return 'User ID: ' . $id;
    }
}

Register the controller route:

$router->get('/user/{id}', 'UserController@show');

Middleware

Creating Middleware:

Generate middleware:

php artisan make:middleware <MiddlewareName>

Example Middleware:

 
namespace App\Http\Middleware;

use Closure;

class ExampleMiddleware
{
    public function handle($request, Closure $next)
    {
        // Perform action
        return $next($request);
    }
}

Registering Middleware:

Register in bootstrap/app.php:

$app->routeMiddleware([ 'example' => App\Http\Middleware\ExampleMiddleware::class ]);

Applying Middleware:

Apply to a route:

$router->get('/admin', ['middleware' => 'example', function () { return 'Admin Area'; }]);

Request & Response

Accessing Request Data:

use Illuminate\Http\Request;

$router->post('/submit', function (Request $request) {
    $name = $request->input('name');
    return 'Hello, ' . $name;
});

Returning JSON Responses:

return response()->json(['message' => 'Success', 'data' => []], 200);

Setting Headers:

return response('Hello World')->header('Content-Type', 'text/plain');

Database & Models

Database Configuration

Configure database settings in .env file:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=lumen_db
DB_USERNAME=homestead
DB_PASSWORD=secret

Ensure Eloquent is enabled in bootstrap/app.php:

$app->withEloquent();

Eloquent Models

Creating a Model:

 
namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $fillable = ['name', 'email'];
    protected $table = 'users';
}

Using a Model:

 
use App\User;

$router->get('/users', function () {
    $users = User::all();
    return response()->json($users);
});

Model Attributes:

$fillable - attributes that can be mass-assigned.
$table - the table associated with the model.
$primaryKey - the primary key column.
$timestamps - whether to maintain timestamps (created_at, updated_at).

Database Migrations

Create a migration:

php artisan make:migration create_users_table

Example migration file:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateUsersTable extends Migration
{
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('users');
    }
}

Run migrations:

php artisan migrate

Authentication & Authorization

Authentication

Lumen provides basic authentication scaffolding. Consider using Passport or JWT for more robust authentication.

Using basic authentication middleware:

$router->get('/profile', ['middleware' => 'auth', function () {
    return 'User Profile';
}]);

Authorization (Policies)

Creating a Policy:

 
namespace App\Policies;

use App\User;
use App\Post;

class PostPolicy
{
    public function update(User $user, Post $post)
    {
        return $user->id === $post->user_id;
    }
}

Registering a Policy:

Register the policy in AuthServiceProvider:

protected $policies = [
    App\Post::class => App\Policies\PostPolicy::class,
];

Using a Policy:

 
use Illuminate\Support\Facades\Gate;

$router->put('/post/{id}', function ($id) {
    $post = App\Post::findOrFail($id);
    if (Gate::allows('update', $post)) {
        // Update the post
    }
});

Events & Listeners

Define events and listeners to decouple components.

Example Event:

namespace App\Events;

use App\User;
use Illuminate\Queue\SerializesModels;

class UserRegistered
{
    use SerializesModels;

    public $user;

    public function __construct(User $user)
    {
        $this->user = $user;
    }
}

Example Listener:

namespace App\Listeners;

use App\Events\UserRegistered;

class SendWelcomeEmail
{
    public function handle(UserRegistered $event)
    {
        // Send welcome email to $event->user
    }
}

Register events and listeners in app/Providers/EventServiceProvider.php.
Download PDF