Builder & Strategy Pattern

Builder & Strategy Pattern in Laravel Reporting System

Modern reporting systems often become complex very quickly—multiple filters, dynamic data sources, export formats, and business rules. If not designed properly, the code turns into a mess of if-else conditions and tightly coupled logic.

Two design patterns that can significantly improve your Laravel reporting architecture are:

• Builder Pattern → for constructing complex reports step-by-step

• Strategy Pattern → for handling interchangeable business logic (filters, formats, calculations)

Let’s break them down with real Laravel use cases.

---

1. Builder Pattern in Laravel Reporting

🧠 Problem

In reporting systems, you often need to dynamically build queries like:

• Filter by date range

• Filter by user / branch / status

• Add joins conditionally

• Apply sorting, grouping

If you handle everything inside one method, it becomes unmaintainable.

---

✅ Solution: Builder Pattern

The Builder Pattern helps you construct complex queries step-by-step, keeping your code modular and readable.

---

🏗 Example: Report Builder Class

class SalesReportBuilder
{
    protected $query;

    public function __construct()
    {
        $this->query = DB::table('orders');
    }

    public function filterByDate($from, $to)
    {
        $this->query->whereBetween('created_at', [$from, $to]);
        return $this;
    }

    public function filterByStatus($status)
    {
        $this->query->where('status', $status);
        return $this;
    }

    public function filterByUser($userId)
    {
        $this->query->where('user_id', $userId);
        return $this;
    }

    public function withTotalAmount()
    {
        $this->query->selectRaw('SUM(amount) as total');
        return $this;
    }

    public function get()
    {
        return $this->query->get();
    }
}

---

🚀 Usage

$report = (new SalesReportBuilder())
    ->filterByDate($from, $to)
    ->filterByStatus('completed')
    ->withTotalAmount()
    ->get();

---

💡 Benefits

• Clean and readable

• Reusable query parts

• Easy to extend (add new filters without breaking code)

• Avoids massive controller logic

---

2. Strategy Pattern in Laravel Reporting

🧠 Problem

Reports often vary in behavior:

• Different calculation logic (commission, profit, tax)

• Different export formats (PDF, Excel, CSV)

• Different grouping logic

Using if-else everywhere makes code fragile.

---

✅ Solution: Strategy Pattern

The Strategy Pattern allows you to swap algorithms dynamically.

---

🧩 Example: Report Calculation Strategy

Step 1: Create Interface

interface ReportStrategy
{
    public function process($data);
}

---

Step 2: Create Concrete Strategies

Profit Report

class ProfitStrategy implements ReportStrategy
{
    public function process($data)
    {
        return $data->sum('amount') - $data->sum('cost');
    }
}

Commission Report

class CommissionStrategy implements ReportStrategy
{
    public function process($data)
    {
        return $data->sum('commission');
    }
}

---

Step 3: Context Class

class ReportService
{
    protected $strategy;

    public function __construct(ReportStrategy $strategy)
    {
        $this->strategy = $strategy;
    }

    public function generate($data)
    {
        return $this->strategy->process($data);
    }
}

---

🚀 Usage

$data = DB::table('orders')->get();

// dynamically choose strategy
$strategy = new ProfitStrategy();

$service = new ReportService($strategy);

$result = $service->generate($data);

---

💡 Benefits

• Removes complex conditional logic

• Easy to add new report types

• Follows Open/Closed Principle (no modification needed, just extend)

---

3. Combining Builder + Strategy (Best Practice)

In real Laravel systems, you should combine both patterns:

🔥 Flow

1. Builder → prepares data (query)

2. Strategy → processes data (business logic)

---

🧱 Combined Example

$builder = (new SalesReportBuilder())
    ->filterByDate($from, $to)
    ->filterByStatus('completed');

$data = $builder->get();

// dynamic strategy selection
$strategy = match($type) {
    'profit' => new ProfitStrategy(),
    'commission' => new CommissionStrategy(),
};

$result = (new ReportService($strategy))->generate($data);

---

4. Real-Life Use Cases in Laravel Projects

You can apply this in:

📊 ERP / Garments System

• Production reports

• Line efficiency reports

• Cost analysis

🛒 E-commerce

• Sales reports

• Customer insights

• Revenue analytics

---

5. Pro Tips (From Production Experience)

• Use DTOs or Collections instead of raw arrays

• Cache heavy reports (Redis)

• Use chunking / cursor for large data

• Separate:

  • Query (Builder)

  • Logic (Strategy)

  • Output (Transformer / Export)

---

✅ Conclusion

Using Builder and Strategy patterns in Laravel reporting systems helps you:

• Keep code clean and scalable

• Reduce duplication

• Handle complex business logic elegantly

• Easily extend features without breaking existing code