DEV Community: Aleson França

Laravel Cashier: Manage Subscriptions with Stripe or Paddle the Easy Way

Aleson França — Thu, 10 Jul 2025 13:02:14 +0000

If you're building a SaaS with Laravel, sooner or later you’ll need to handle recurring payments. Laravel offers a robust solution for that: Cashier. In this post, I’ll show you how to integrate it with Stripe or Paddle and how to manage subscriptions, plan changes, and cancellations easily.

Using Laravel Cashier with stripe

Install package

composer require laravel/cashier
php artisan vendor:publish --tag="cashier-migrations"
php artisan migrate

In your User model:

use Laravel\Cashier\Billable;

class User extends Authenticatable
{
    use Billable;
}

In your .env file:

STRIPE_KEY=pk_test_xxx
STRIPE_SECRET=sk_test_xxx

Create a Subscription

$user = User::find(1);

$user->newSubscription('default', 'premium-plan-id')
     ->create($paymentMethodId);

You can get the paymentMethodId using Stripe Elements.

Canceling and Managing a Subscription

$user->subscription('default')->cancel();

$user->subscription('default')->cancelNow();

Switch Plans

$user->subscription('default')->swap('new-plan-id');

One Time Charge (No subscription)

$user->charge(2500, $paymentMethodId); // $25.00

Using Laravel Cashier with Paddle

To use Paddle, you need a separate package:

Installation

composer require laravel/cashier-paddle
php artisan vendor:publish --tag="cashier-paddle-migrations"
php artisan migrate

In your .env file:

PADDLE_VENDOR_ID=your_vendor_id
PADDLE_VENDOR_AUTH_CODE=your_auth_code

Creating a Subscription

$user = User::find(1);

return $user->newSubscription('default', 'plan-id')
            ->checkout([
                'success_url' => route('dashboard'),
                'cancel_url' => route('checkout.cancelled'),
            ]);

With Paddle, the checkout is hosted on Paddle's platform.

Canceling a Subscription

$user->subscription('default')->cancel();

Handling Webhooks

Both Stripe and Paddle send webhook events when something happens, such as:

Payment failed
Card expired
Subscription canceled
Subscription created

You can set up webhook routes in Laravel like this:

Route::post('/webhook/stripe', [WebhookController::class, 'handleStripe']);
Route::post('/webhook/paddle', [WebhookController::class, 'handlePaddle']);

Tips

Use jobs to handle webhook events asynchronously
Use middleware to block access to premium features for inactive users
Create artisan commands to check for expired subscriptions

Conclusion

Laravel Cashier removes most of the complexity when dealing with recurring payments and subscriptions. With native support for both Stripe and Paddle, you can choose the provider that fits your business best.

If you're building a SaaS product with Laravel, this is one of the most complete and production-ready solutions available today.

Laravel + InertiaJS + React: A modern fullstack approach

Aleson França — Mon, 07 Jul 2025 13:11:17 +0000

Have you ever wanted to build apps using Laravel on the backend and React on the frontend, but without the complexity of creating full JSON APIs, handling tokens, and making AJAX calls for everything?

Meet Inertia.js the glue between Laravel and React that helps you build modern apps without needing a separate API layer.

What is Inertia.js ?

Inertia.js is a library that lets you build Single Page Applications (SPAs) using frameworks like Laravel + React/Vue/Svelte without building a traditional JSON API.

Think of Inertia as a client-side router that works directly with your Laravel routes, passing props from your controller directly into your React components.

How its work ?

You still use Laravel controllers, but instead of returning view(), you return Inertia::render().

In your React components, you receive the data as props.

Setup

composer require inertiajs/inertia-laravel
npm install @inertiajs/inertia @inertiajs/inertia-react

In resources/js/app.jsx:

import { createRoot } from 'react-dom/client'
import { createInertiaApp } from '@inertiajs/inertia-react'

createInertiaApp({
  resolve: name => require(`./Pages/${name}`),
  setup({ el, App, props }) {
    createRoot(el).render(<App {...props} />)
  },
})

Creating first page

Laravel Controller

use Inertia\Inertia;

public function index()
{
    $users = User::latest()->get();

    return Inertia::render('Users/Index', [
        'users' => $users,
    ]);
}

React Componente:
resources/js/Pages/Users/Index.jsx

import React from 'react'
import { usePage } from '@inertiajs/inertia-react'

export default function Index() {
  const { users } = usePage().props

  return (
    <div>
      <h1>User List</h1>
      <ul>
        {users.map(user => (
          <li key={user.id}>{user.name} ({user.email})</li>
        ))}
      </ul>
    </div>
  )
}

Forms with Inertia + React

Laravel Controller:

public function store(Request $request)
{
    $request->validate([
        'name' => 'required',
        'email' => 'required|email|unique:users',
    ]);

    User::create($request->only('name', 'email'));

    return redirect()->route('users.index')->with('success', 'User created!');
}

React Form:

import { useForm } from '@inertiajs/inertia-react'

export default function CreateUser() {
  const { data, setData, post, errors } = useForm({
    name: '',
    email: '',
  })

  const handleSubmit = e => {
    e.preventDefault()
    post('/users')
  }

  return (
    <form onSubmit={handleSubmit}>
      <input
        type="text"
        value={data.name}
        onChange={e => setData('name', e.target.value)}
        placeholder="Name"
      />
      {errors.name && <div>{errors.name}</div>}

      <input
        type="email"
        value={data.email}
        onChange={e => setData('email', e.target.value)}
        placeholder="Email"
      />
      {errors.email && <div>{errors.email}</div>}

      <button type="submit">Save</button>
    </form>
  )
}

Bonus: Sharing data with handleInertiaRequests

In AppServiceProvider:

use Inertia\Inertia;

public function boot()
{
    Inertia::share([
        'auth' => fn () => [
            'user' => auth()->user(),
        ],
        'flash' => fn () => [
            'success' => session('success'),
        ],
    ]);
}

In React:

const { auth, flash } = usePage().props

It’s ideal for building modern SPAs in a clean and simple way.
Inertia.js connects Laravel with React without building a JSON API.
You use Laravel controllers and React components like traditional views.

Conclusion

Inertia.js is a great choice if you want to build modern SPAs without losing the power and simplicity of the Laravel ecosystem.

With Inertia, you can:

Enjoy React’s flexibility and interactivity;
Keep using Laravel’s routes, controllers, validation, and auth;
Avoid the extra complexity of managing separate REST or GraphQL APIs.

If you're coming from Blade and want to move into the React world, Inertia is the most natural and productive path to start.

Laravel Form Requests + Custom Rules: Powerful, Scalable, and Smart Validation

Aleson França — Thu, 03 Jul 2025 12:37:10 +0000

Still validating data directly in your controller? Let’s level up your Laravel skills with:

Form Request for clean validation
Reusable Custom Rules
Smart array validation with advanced logic

Let me show you real-world examples.

Using Form Requests for cleaner code

Generate a request:

php artisan make:request StoreUserRequest

// app/Http/Requests/StoreUserRequest.php
public function rules(): array
{
    return [
        'name' => 'required|string|min:3',
        'email' => 'required|email|unique:users,email',
        'password' => ['required', 'min:8', new StrongPassword],
    ];
}

Custom Rule: StrongPassword

php artisan make:rule StrongPassword

public function passes($attribute, $value): bool
{
    return preg_match('/^(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$/', $value);
}

This rule checks for:

At least 1 uppercase letter
At least 1 number
At least 1 special character

Validating arrays of objects: Order items examples

POST /api/orders

{
  "customer_id": 1,
  "items": [
    { "product_id": 101, "quantity": 2 },
    { "product_id": 202, "quantity": 5 }
  ]
}

public function rules(): array
{
    return [
        'customer_id' => 'required|exists:customers,id',
        'items' => 'required|array|min:1',
        'items.*.product_id' => 'required|exists:products,id',
        'items.*.quantity' => 'required|integer|min:1',
    ];
}

Custom validation for each item in array

Let’s check if the quantity is not greater than the product stock using Rule::forEach.

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'items' => ['required', 'array', 'min:1'],
        'items.*' => Rule::forEach(function ($item, $index) {
            return [
                'product_id' => ['required', Rule::exists('products', 'id')],
                'quantity' => [
                    'required',
                    'integer',
                    'min:1',
                    function ($attribute, $value, $fail) use ($item) {
                        $product = \App\Models\Product::find($item['product_id']);
                        if ($product && $value > $product->stock) {
                            $fail("The quantity in {$attribute} exceeds available stock.");
                        }
                    }
                ]
            ];
        })
    ];
}

Reusable Custom Rule for arrays

php artisan make:rule HasSufficientStock

class HasSufficientStock implements Rule
{
    public function __construct(public int $productId) {}

    public function passes($attribute, $value): bool
    {
        $product = Product::find($this->productId);
        return $product && $value <= $product->stock;
    }

    public function message(): string
    {
        return 'Quantity exceeds available stock.';
    }
}

Usage:

'items.*.quantity' => [
    'required',
    'integer',
    function ($attribute, $value, $fail) use ($request, $index) {
        $productId = $request->input("items.$index.product_id");
        if ($productId) {
            $rule = new HasSufficientStock($productId);
            if (!$rule->passes($attribute, $value)) {
                $fail($rule->message());
            }
        }
    }
],

Testing validation with arrays

public function test_fails_if_quantity_exceeds_stock(): void
{
    Product::factory()->create(['id' => 1, 'stock' => 5]);

    $response = $this->postJson('/api/orders', [
        'customer_id' => 1,
        'items' => [
            ['product_id' => 1, 'quantity' => 10]
        ]
    ]);

    $response->assertStatus(422);
    $response->assertJsonValidationErrors(['items.0.quantity']);
}

Conclusion

Using Form Requests, Custom Rules, and smart array validation gives you:

Clean and maintainable code
Reusable validation logic
Better test coverage
Safer and more predictable APIs

Have you used Rule::forEach in your Laravel project or some other kind of validation or custom rules? Or are you still validating everything inside your controller ?

Clean Architecture with PHP + Laravel

Aleson França — Mon, 30 Jun 2025 12:51:50 +0000

Have you ever felt your laravel project is getting hard to maintain ?
Fat controller, mixed logic, validations everywhere. That's where clean arch can help !
In this post, i'll show you how to apply Clean Arch in a simple Crud
using laravel with step by step examples and tests.

What is Clean Arch ?

It's a way to organize code based on responsibilities, not technology.
The ideia is to separate your system into layers:

Domain: Pure Business rules.
Use Cases(App): They make the logic work and use the entities to solve particular problems.
Interface Adapters: They change data between the outside and inside parts (Controllers, Repositories, Presenters).
Infrastructure: Eloquent, Database, external tools

Domain (User) Entity

class User {
    public function __construct(
        public ?int $id,
        public string $name,
        public string $email,
    ) {}

    public static function create(string $name, string $email): self {
        return new self(null, $name, $email);
    }
}

DTOs

class CreateUserDTO {
    public function __construct(public string $name, public string $email) {}
}

class UpdateUserDTO {
    public function __construct(public int $id, public string $name, public string $email) {}
}

(User) Repository Contract

interface UserRepository {
    public function save(User $user): User;
    public function find(int $id): ?User;
    public function all(): array;
    public function delete(int $id): void;
}

Eloquent Implementation

class UserRepository implements UserRepository {
    public function save(User $user): User {
        $model = $user->id ? UserModel::findOrFail($user->id) : new UserModel();
        $model->name = $user->name;
        $model->email = $user->email;
        $model->save();
        return new User($model->id, $model->name, $model->email);
    }

    // Other methods: find(), all(), delete()
}

Note: this class depends on Eloquent, but the rest of the system does not.

Use Case (Create User)

class CreateUser {
    public function __construct(private UserRepository $repo) {}

    public function execute(CreateUserDTO $dto): User {
        $user = User::create($dto->name, $dto->email);
        return $this->repo->save($user);
    }
}

Controller

class UserController {
    public function store(StoreUserRequest $req, CreateUser $uc) {
        $dto = new CreateUserDTO(...$req->only(['name', 'email']));
        $user = $uc->execute($dto);
        return new UserResource($user);
    }

    // Other methods: index(), show(), update(), destroy()
}

Validation with FormRequests

class StoreUserRequest extends FormRequest {
    public function rules(): array {
        return ['name' => 'required', 'email' => 'required|email|unique:users'];
    }
}

Output Resource

class UserResource extends JsonResource {
    public function toArray($request): array {
        return ['id' => $this->id, 'name' => $this->name, 'email' => $this->email];
    }
}

Tests

Unit test (Use Case):

it('creates user successfully', function (): void {
    $repo = Mockery::mock(UserRepository::class);
    $repo->shouldReceive('save')->once()->andReturn(new User(1, 'Name', 'name@ex.com'));

    $uc = new CreateUser($repo);
    $dto = new CreateUserDTO('Aleson', 'name@ex.com');
    $user = $uc->execute($dto);

    expect($user->id)->toBe(1);
});

Feature test(API)

it('creates user through API', function (): void {
    $this->postJson('/api/users', [
        'name' => 'Aleson',
        'email' => 'a@ex.com'
    ])
    ->assertCreated()
    ->assertJson(['name' => 'Aleson']);
});

Conclusion

By using just a few more files, you get:
✅ Testable code
✅ Clear separation of concerns
✅ Independence from the framework
✅ Long-term maintainability

If you want to scale your project with confidence, this is a great way to start!

Laravel Tips: For Beginners

Aleson França — Mon, 23 Jun 2025 12:32:13 +0000

Working with Laravel is great, but we can always improve how we use the framework. Here are 5 quick tips to help you write better code:

Use `when()` instead of `if` in Eloquent

User::query()
    ->when($isActive, fn($q) => $q->where('active', true))
    ->get();

This avoids external if statements and makes the query cleaner.

Use Resources to format API responses

Avoid return $user directly. Instead, use:

return new UserResource($user);

This helps with versioning, security, and response clarity.

Use Laravel's `Str` helper

Str::slug('Post Title') // returns: post-title

Simple, powerful, and more readable.

Don't put heavy logic in Controller

Use Services, Actions, to keep your controllers clean and easy to read.

Write tests with Pest

it('creates a user', function () {
    $response = post('/users', [...]);

    $response->assertCreated();
});

Clean syntax, easy to write and maintain.

Bonus: Use php artisan model:show User to view relationships right in your terminal.

Start With CI/CD using GitHub Actions - Beginner's Guide

Aleson França — Wed, 18 Jun 2025 14:35:07 +0000

Have you heard about CI/CD but don’t know where to begin?
Maybe you saw the word “pipeline” and thought it was only for DevOps experts?

Don’t worry! With GitHub Actions, you can automate tests and deployments directly from your GitHub repository. And the best part? It’s easy to start!

What is CI/CD ?

CI (Continuous Integration): Every time you push code, tests run automatically.
CD (Continuous Delivery): When the code is approved, it is automatically deployed to production or staging.

This saves time and helps you avoid manual mistakes in your deployments

How to start using GitHub Actions?

Create a folder named .github/workflows in your project
Add a file called ci.yml with the content below:

name: CI Pipeline

on:
  push:
    branches: [main] # Runs on push to the main branch

jobs:
  test:
    runs-on: ubuntu-latest # Linux environment

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm install

      - name: Run tests
        run: npm run test

Explaning each part

on.push.branches: When the workflow runs (in this case, on push to main)
runs-on: Which OS to use (Ubuntu, Windows, etc.)
steps: Each action in you pipeline:

checkout: Clones you repo
setup-node: installs Node.js
npm install: Installs packages
npm run test: Runs your tests

What happens Next?

Every time you git push to the main branch, GitHub will:

Run your tests
Show the result in the Actions tab
Notify you if something fails!

What about deployment?

After your tests work, you can add deployment steps

Example 1: Deploy to Laravel Forge

- name: Deploy to Laravel Forge
  run: curl -X POST ${{ secrets.FORGE_DEPLOY_HOOK }}

In forge, enable the deploy hook and save the URL in GitHub secrets as FORGE_DEPLOY_HOOK.

Example 2: Deploy to Vercel

- name: Deploy to Vercel
  run: npx vercel --prod --token=$VERCEL_TOKEN
  env:
    VERCEL_TOKEN: ${{ secrets.VERCEL_TOKEN }}

Generate a personal token at Vercel and save it in GitHub secrets as VERCEL_TOKEN

Full pipeline (tests + deploy to Forge):

name: CI + Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Node
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - run: npm install
      - run: npm run test

      - name: Deploy to Forge
        run: curl -X POST ${{ secrets.FORGE_DEPLOY_HOOK }}

Final Tip

Start Small:

First, configure your tests
Then add your deploy steps
Later, include security checks, build, lint, etc.

How to Optimize Docker Images for Laravel Apps: A Simple Guide

Aleson França — Mon, 16 Jun 2025 11:54:23 +0000

If you already used Docker with a Laravel app, you know the final image can get big and that affects build time, deployment speed, and even storage cost.

In this post, I'll show you how to make you Docker image smaller and faster using multi-stage builds, lightweight images, and a few best practices.

Basic Structure

Here is a real example using PHP 8.3 + Laravel + Composer + Node for front assets:

# Stage 1: Build the app dependencies
FROM composer:2.7 as vendor

WORKDIR /app

COPY composer.json composer.lock ./
RUN composer install --no-dev --prefer-dist --optimize-autoloader

COPY . .

# Stage 2: Build frontend assets (optional)
FROM node:20-alpine as frontend

WORKDIR /app

COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

# Stage 3: Final production image (clean and light)
FROM php:8.3-fpm-alpine

RUN apk add --no-cache \
    bash curl libpng libjpeg-turbo-dev libzip-dev oniguruma-dev \
    && docker-php-ext-install pdo pdo_mysql zip mbstring

WORKDIR /var/www

COPY --from=vendor /app /var/www
COPY --from=frontend /app/public/build /var/www/public/build

RUN chown -R www-data:www-data /var/www

USER www-data

Best Practices

Use Alpine Images they are much smaller and good for prod.
Split the build into stages This keeps dev tools out of the final image.
Do not install Composer or Node in the final Image this reduces the size and security risks.
Don't use COPY . . at the end copy only what you really need (no .env, .git, tests, etc).

Before And After

A non optimize image can be 1.2GB or more.
With multi-stage builds and Alpine, it can be under 200MB!

Extra Security Tips

Use USER www-data at the end
Add a .dockerignore file

node_modules
vendor
.env
.git
tests

Final Thoughts

Optimized Docker images are faster, safer, and cheaper.
Have youy optimized you Laravel Setup ? Do you have other tips ?

Laravel Service Container: Do you understand what's behind app() and dependency injection ?

Aleson França — Wed, 11 Jun 2025 14:47:47 +0000

If you work with Laravel, you’ve probably used app(), resolve(), or seen how dependencies are automatically injected into class constructors.

But have you ever stopped to think how this really works under the hood?

The Service Container in Laravel is a powerful dependency injection system and understanding it better can help you write cleaner, more testable, and decoupled code.

What Is The Service Container ?

It's an IoC (Inversion of Control) container that resolves classes and their dependecies.
Every time you inject something into a controller, job, or service, Laravel uses the container to handle it.

final class UserController
{
    public function __construct(UserService $service)
    {
        // Laravel uses the container to resolve UserService
        $this->service = $service;
    }
}

How to register things in the container

You can register custom bindings using bind, singleton, or instance.

app()->bind(PaymentGateway::class, StripeGateway::class);

Or as a singleton (one shared instance for the whole app):

app()->singleton(LoggerInterface::class, function () {
    return new FileLogger('/var/log/app.log');
});

Why is this important?

Testability: You can easily replace dependencies with mocks.
Decoupling: Your code dependes on contracts, not implementations.
Flexibility: You can switch services without changing your main logic.

Tip

To make your code cleaner and easier to test, create you own interfaces and bindings in the AppServiceProvider

public function register()
{
    $this->app->bind(
        \App\Contracts\Notifier::class,
        \App\Services\EmailNotifier::class
    );
}

Now it's easy to change notifications to Slack, SMS, or anything else without touching the rest of the app.

Conclusion

The Service Container is one of the most powerful and often underrated features in Laravel.

If you take the time to understand how it works, you can unlock cleaner architecture, better testability, and more flexible code.

It's not just about using app() or automatic injection it's about designing you app to be modular and maintainable.

Create a custom binding use interfaces, and test how easy it is to switch implementations.
You'll be surprised how much control the container gives you.

PHP + Laravel + FFmepg

Aleson França — Mon, 09 Jun 2025 12:22:27 +0000

Did you know you can use FFmpeg inside your Laravel project? With it, you can convert video formats, create thumbnails, or get video metadata easily. Laravel works great with this powerful command-line tool using some handy PHP libraries.

Example: Create a video thumb

use FFMpeg;

FFMpeg->open('myvideo.mp4')
    ->getFrameFromSeconds(2)
    ->export()
    ->toDisk('thumbnails')
    ->save('myvideo-thumbnail.jpg');

What this code does:

Open a video from the videos disk
Gets the frame at second 2
Saves the image to the thumbnails disk

Common use cases:

Automatic thumbnail generation
Video format conversion (.mp4, webm)
Getting video info like duration and bitrate
Cutting a specific part of the videos

Tip: Use laravel queue to process videos the background and keep your app fast.

Conclusion

Working with videos doesn’t need to be hard. With Laravel and FFmpeg, you can build powerful video features without leaving your PHP backend. From thumbnails to video conversion, everything can be automated and cleanly integrated into your app.

If you're building a platform with media content, give this combo a try it can save you a lot of time and effort.

Abstract Factory: Create Object With Elegance

Aleson França — Fri, 06 Jun 2025 12:06:22 +0000

Have you ever needed to create several related objects, like UI components for different themes (light/dark), databases, or API drivers? If yes, you probably noticed that keeping your code flexible and easy to maintain can be hard. This is where the Abstract Factory pattern helps.

In this post, I will show you how to use Abstract Factory in PHP, with simple examples and tips from real experience.

The Problem

Imagine you are building a user interface that can be shown in light or dark theme. Each theme has its own button and checkbox. Without a pattern, your code might look like this:

if ($theme === 'dark') {
    $button = new DarkButton();
    $checkbox = new DarkCheckbox();
} else {
    $button = new LightButton();
    $checkbox = new LightCheckbox();
}

This works, but it is hard to maintain. If you want to add a new theme, you need to change your code in many places. Also, you might mix components from different themes by mistake.

Solution: Abstract Factory

The Abstract Factory pattern solves this problem by creating an interface to produce families of related objects, without depending on their concrete classes.

Define Interfaces

interface Button {
    public function render(): void;
}

interface Checkbox {
    public function render(): void;
}

Implement the concrete class

class LightButton implements Button {
    public function render(): void {
        echo "Light Button<br>";
    }
}

class DarkButton implements Button {
    public function render(): void {
        echo "Dark Button<br>";
    }
}

class LightCheckbox implements Checkbox {
    public function render(): void {
        echo "Light Checkbox<br>";
    }
}

class DarkCheckbox implements Checkbox {
    public function render(): void {
        echo "Dark Checkbox<br>";
    }
}

Create the abstract factory

interface UIFactory {
    public function createButton(): Button;
    public function createCheckbox(): Checkbox;
}

Implement concrete factories

class LightFactory implements UIFactory {
    public function createButton(): Button {
        return new LightButton();
    }
    public function createCheckbox(): Checkbox {
        return new LightCheckbox();
    }
}

class DarkFactory implements UIFactory {
    public function createButton(): Button {
        return new DarkButton();
    }
    public function createCheckbox(): Checkbox {
        return new DarkCheckbox();
    }
}

How to use implementation

function renderUI(UIFactory $factory) {
    $button = $factory->createButton();
    $checkbox = $factory->createCheckbox();
    $button->render();
    $checkbox->render();
}


$theme = 'dark';
$factory = $theme === 'dark' ? new DarkFactory() : new LightFactory();
renderUI($factory);

Advantages

Decoupling: The client code does not need to know which concrete classes are used.
Consistency: It makes sure all objects created belong to the same family(theme)
Easy to extend: To add a new theme, just create a new factory and new concrete products.

Conclusion

Abstract Factory can look complex at first, but it is an elegant solution for real problems of maintenance and scalability. In big projects, it really helps to organize your code.

Adapter Pattern in PHP

Aleson França — Wed, 04 Jun 2025 11:35:11 +0000

What is the Adapter pattern?

The Adapter is a structural pattern from the GoF (Gang Of Four) catalog. It allows classes with incompatible interfaces to work together.

It acts like a "translate" between two interfaces.

This is very useful when you need to integrate a library or and old system into your modern app without changing the original code.

Classic Problem

Imagine you use a library to send SMS, but your system only works with the NotificationInterface

interface NotificationInterface {
    public function send(string $to, string $message): bool;
}

But the library you want to use offers this class:

class SmsService {
    public function sendSms(string $phoneNumber, string $text): bool {
        // Sending logic
        return true;
    }
}

The method names and parameters are different! You can't replace one with the other directly.
Here is where the Adapter helps!

Solution: creating an adapter

We create a class that implements the expected interface and delegates the call to the library.

class SmsAdapter implements NotificationInterface
{
    private SmsService $smsService;

    public function __construct(SmsService $smsService)
    {
        $this->smsService = $smsService;
    }

    public function send(string $to, string $message): bool
    {
        // Adapt the call
        return $this->smsService->sendSms($to, $message);
    }
}

Now, any part of the system that depends on NotificationInterface can use SmsAdapter easily:

$smsService = new SmsService();
$notification = new SmsAdapter($smsService);

$notification->send('+5511999999999', 'Hi, you have a new message!');

Benefits of using Adapter

Decoupling: Your system dependes only on the interface, not on the concrete class.
Reuse: Integrate old systems or third-part libraries without changing their code.
Maintenance: It is easier to replace or update dependencies in the future.

When not to use it

If you can change the library, maybe it is better to make the interface match directly.
If you need to adapt many methods, maybe you should rethink your architecture.

Optimizing Laravel Queries

Aleson França — Mon, 02 Jun 2025 12:35:15 +0000

If you are building applications with Laravel, query optimization is very important for performance. In this post, I will show you simple and practical tips to make your Laravel queries faster and more efficient.

Use Eager Loading

When you use relationships, always try to use with() to avoid the N+1 problem.

Bad Example

$users = User::all();
foreach ($users as $user) {
    echo $user->profile->bio;
}

Good Example:

$users = User::with('profile')->get();
foreach ($users as $user) {
    echo $user->profile->bio;
}

Select Only The Columns You Need

Always select only the fields you really need.

$users = User::select('id', 'name')->get();

Use Chunk For Big Data

If you need to work with a large number of records, use chunk() to save memory.

User::chunk(100, function($users) {
    foreach ($users as $user) {
        // process user
    }
});

Add Indexes in Your Database

If you use a column in WHERE, ORDER BY or JOIN, you should create an index to make the query faster.

Cache Expensive Queries

If you run the same query many times, use Laravel cache.

$users = Cache::remember('users.all', 60, function() {
    return User::all();
});

Use `when()` for conditional queries

This makes your code cleaner and more readable.

$query = User::query();
$query->when($active, function($q) {
    return $q->where('status', 'active');
});
$users = $query->get();

Use raw expressions carefully

Sometimes you need more complex queries. Use DB::raw(), but be careful with SQL injection.

$users = User::select(DB::raw('count(*) as user_count, status'))
              ->groupBy('status')
              ->get();

Profile your queries

Use Laravel DebugBar or DB::listen() to see what queries are running.

DB::listen(function($query) {
    logger($query->sql);
});

Use Pagination

When showing data in frontend, always use paginate() or cursorPaginate().

$users = User::paginate(15);

Use `exists()` or `count()`

If you only need to know if a record exists, do not use get().

if (User::where('email', $email)->exists()) {
    // user exists
}

Conclusion

With these simple tips, you can make your Laravel queries much faster and more efficient. Start applying them today in your project!

DEV Community: Aleson França

Laravel Cashier: Manage Subscriptions with Stripe or Paddle the Easy Way

Using Laravel Cashier with stripe

Create a Subscription

Canceling and Managing a Subscription

Switch Plans

One Time Charge (No subscription)

Using Laravel Cashier with Paddle

Creating a Subscription

Canceling a Subscription

Handling Webhooks

Tips

Conclusion

Laravel + InertiaJS + React: A modern fullstack approach

What is Inertia.js ?

How its work ?

Setup

Creating first page

Forms with Inertia + React

Bonus: Sharing data with handleInertiaRequests

Conclusion

Laravel Form Requests + Custom Rules: Powerful, Scalable, and Smart Validation

Using Form Requests for cleaner code

Custom Rule: StrongPassword

Validating arrays of objects: Order items examples

Custom validation for each item in array

Reusable Custom Rule for arrays

Testing validation with arrays

Conclusion

Clean Architecture with PHP + Laravel

What is Clean Arch ?

Domain (User) Entity

DTOs

(User) Repository Contract

Eloquent Implementation

Use Case (Create User)

Controller

Validation with FormRequests

Output Resource

Tests

Conclusion

Laravel Tips: For Beginners

Use when() instead of if in Eloquent

Use Resources to format API responses

Use Laravel's Str helper

Don't put heavy logic in Controller

Write tests with Pest

Start With CI/CD using GitHub Actions - Beginner's Guide

What is CI/CD ?

How to start using GitHub Actions?

Explaning each part

What happens Next?

What about deployment?

Example 1: Deploy to Laravel Forge

Example 2: Deploy to Vercel

Full pipeline (tests + deploy to Forge):

Final Tip

How to Optimize Docker Images for Laravel Apps: A Simple Guide

Basic Structure

Best Practices

Before And After

Extra Security Tips

Final Thoughts

Laravel Service Container: Do you understand what's behind app() and dependency injection ?

What Is The Service Container ?

How to register things in the container

Why is this important?

Tip

Conclusion

PHP + Laravel + FFmepg

Example: Create a video thumb

Common use cases:

Conclusion

Abstract Factory: Create Object With Elegance

The Problem

Solution: Abstract Factory

Define Interfaces

Implement the concrete class

Create the abstract factory

Implement concrete factories

Use `when()` instead of `if` in Eloquent

Use Laravel's `Str` helper

Use `when()` for conditional queries

Use `exists()` or `count()`