Handling Resources in Laravel

When working with Laravel, managing data resources efficiently is key to creating clean and maintainable code. Laravel provides a robust way to handle API responses and data transformation through resource classes. In this guide, we'll explore how to handle resources using a custom helper class and demonstrate how to integrate it with nested resources.

1. Introduction

In Laravel, resources help transform models and collections into JSON responses, making it easier to structure and format data. We'll use a custom helper class, JsonResourceHelper, to streamline resource management and demonstrate its usage with nested resources.

2. Creating the JsonResourceHelper Class

The JsonResourceHelper class extends Laravel’s JsonResource and provides additional functionality to simplify resource handling.

<?php

namespace App\Helpers;

use Closure;
use Illuminate\Http\Resources\Json\JsonResource;

class JsonResourceHelper extends JsonResource
{
    public function __construct($resource)
    {
        $this->resource = $resource;
    }

    public function getResourceCollection($callback): array
    {
        $data = [];
        foreach ($this->resource as $resource) {
            $data[] = $this->getResource($resource, $callback);
        }
        return $data;
    }

    public function getResourceItem($callback)
    {
        return $this->getResource($this->resource, $callback);
    }

    public function getResource($resource, $closure)
    {
        if (!isset($resource)) return null;

        return new (new class($resource, $closure) extends JsonResourceHelper {
            protected Closure $closure;

            public function __construct($resource, $closure)
            {
                parent::__construct($resource);
                $this->closure = $closure;
            }

            public function toArray($request)
            {
                return ($this->closure)($this);
            }
        })($resource, $closure);
    }
}

3. Using the Helper in Resource Classes

Let’s see how to use JsonResourceHelper in a Laravel resource class. This example shows how to structure the indexResource for a product entity and related data.

<?php

namespace App\Http\Resources\Admin\Product;

use App\Helpers\JsonResourceHelper;
use App\Http\Resources\Base\CategoryResource;
use App\Http\Resources\Base\SupplierResource;

class IndexResource extends DefaultResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'description' => $this->description,
            'price' => $this->price,
            'category' => (new JsonResourceHelper($this->category))->getResourceItem(function ($item) {
                return [
                    'id' => $item->id,
                    'name' => $item->name,
                ];
            }),
            'supplier' => (new JsonResourceHelper($this->supplier))->getResourceItem(function ($item) {
                return [
                    'id' => $item->id,
                    'name' => $item->name,
                    'contact' => $item->contact,
                ];
            }),
            'related_products' => (new JsonResourceHelper($this->relatedProducts))->getResourceCollection(function ($item) {
                return [
                    'id' => $item->id,
                    'name' => $item->name,
                    'price' => $item->price,
                ];
            }),
        ];
    }
}

2. Folder-Structured Resources for Dynamic Loading

Laravel's MVC architecture allows us to dynamically load resource classes based on the controller and action method. This organization helps maintain clean and scalable code. In an MVC setup, resources can be thought of as the view layer, and structuring them to match the controller and action allows for dynamic and flexible data presentation.

Dynamic Resource Loading Based on Controller

You can dynamically load the appropriate resource class based on the controller and action method, ensuring that your code remains organized and maintainable.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

trait HasDynamicResource
{
    public function getResourceDirectory(): array|string
    {
        return str_replace("Controller", '',
            str_replace("App\\Http\\Controllers\\", '',
                get_class(app('request')->route()->getController())
            )
        );
    }

    public function getResourceClass(): bool|string
    {
        $folder = $this->getResourceDirectory();
        $action = app('request')->route()->getActionMethod();
        $class = 'App\\Http\\Resources\\' . $folder . '\\' . $action . 'Resource';
        if (class_exists($class)) {
            return $class;
        }
        return false;
    }

    public function loadResource($data)
    {
        $resourceClass = $this->getResourceClass() ?: defaultResource::class;
        return $resourceClass::make($data);
    }
}
    

Example Usage in Controller

<?php

namespace App\Http\Controllers;

use App\Models\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    use HasDynamicResource;

    public function show($id)
    {
        $product = Product::findOrFail($id);
        return $this->json($this->loadResource($product));
    }
}
    

Understanding Resource Handling

Retrieving data is not just about fetching information from a database. It plays a vital role in ensuring that your application delivers accurate and up-to-date data to users. A well-structured approach to data retrieval ensures efficiency, reliability, and scalability, which are crucial for a smooth user experience and long-term application success.

Handling resources effectively in Laravel transforms and organizes data to fit your application's needs. Well-structured resources simplify data management and presentation, making your application easier to maintain and scale. Following best practices in resource handling improves development efficiency, code readability, and consistency.