Modernizing API Architecture: Implementing Dependency Injection and Robust Error Handling

Improving System Reliability

The Ryuu-no-Mi/ecommerce_happymami project recently underwent a significant architectural refactor. As our e-commerce platform grew, our monolithic controllers began to suffer from tight coupling and inconsistent error handling, making the codebase increasingly difficult to maintain and debug.

The Challenge

Our previous implementation suffered from several critical issues:

• Controllers were directly instantiating database connections, leading to tight coupling.
• Lack of centralized error handling resulted in inconsistent API responses.
• Transaction management was scattered, increasing the risk of orphaned records during failed writes.

The Solution

We transitioned to a Dependency Injection (DI) pattern to decouple our controllers from database configurations and implemented a unified response strategy. By injecting a shared PDO instance, we achieved better testability and cleaner code.

class BaseController 
{
    protected $db;

    public function __construct(PDO $db)
    {
        $this->db = $db;
    }

    protected function sendJsonResponse(array $data, int $statusCode = 200)
    {
        header('Content-Type: application/json');
        http_response_code($statusCode);
        echo json_encode($data);
    }
}

We also refined our model layer to enforce validation and proper exception handling. This ensures that when a client or order operation fails, the API returns a meaningful message rather than a generic server error.

Key Decisions

1. DI over Global State: Injecting the database connection makes the codebase much easier to unit test.
2. Standardized Responses: Using a base controller to handle all outputs ensures consistency across the entire API.
3. Transaction Safety: Wrapping critical operations like order creation in explicit transactions prevents data corruption.

Results

• Improved stability in order processing workflows.
• Reduced boilerplate code in individual controllers.
• Enhanced debugging capabilities through granular error logging.

Lessons Learned

Moving away from tightly coupled code takes more initial effort, but the gain in maintainability is immediate. Start by decoupling your most frequently changed services—your future self will thank you for the cleaner architecture.

Takeaway: Evaluate your controllers today. If they are manually instantiating dependencies, consider refactoring them to use constructor injection to improve your application's modularity.

Generated with Gitvlg.com