TinyMVC Documentation

HTTP Controllers

Controllers help organize your request handling logic into classes rather than defining everything in route files. Controllers are stored in the app/Http/Controllers directory.

Basic Controllers

Example of a basic controller class:

<?php
        
namespace App\Http\Controllers;

use App\Models\User;

class UserController extends Controller
{
    /**
    * Retrieve the user for the given ID.
    *
    * @param  int  $id
    * @return Response
    */
    public function show(int $id)
    {
        $user = User::findOrFail($id);
        return view('admin.user', compact('user'));
    }
}

Routing to Controllers

Route to controller actions using this syntax:

use App\Http\Controllers\UserController;
        
Route::get('user/{id}', [UserController::class, 'show']);

Note: Route parameters or any dependencies will automatically be injected to your controller methods in the order they appear in the route.

Controller Organization

You can organize controllers using subdirectories:

app/Http/Controllers/
├── Admin/
│   ├── UserController.php
│   └── DashboardController.php
└── Auth/
    ├── LoginController.php
    └── RegisterController.php

Reference nested controllers using namespace syntax:

Route::get('admin/users', [Admin\UserController::class, 'index']);

Note: Use php spark make:controller Photo to generate a new controller.
Or, use php spark make:controller Admin/Photo -r to create a resource controller.

Dependency Injection & Controllers

TinyMVC's service container automatically resolves controller dependencies through constructor and method injection.

Constructor Injection

Type-hint dependencies in your controller's constructor:

<?php

namespace App\Http\Controllers;

use Spark\Http\Auth;

class UserController
{
    /**
     * Create a new controller instance.
     *
     * @param  Spark\Http\Auth  $auth
     * @return void
     */
    public function __construct(private Auth $auth)
    {
    }
}

Note: The service container will automatically resolve and inject dependencies declared in your constructor.

Method Injection

Inject dependencies directly into controller methods:

<?php

namespace App\Http\Controllers;

use Spark\Http\Request;

class UserController
{
    /**
     * Store a new user.
     *
     * @param  Request  $request
     * @return Response
     */
    public function store(Request $request)
    {
        $input = $request->validate([
            'name' => 'required|string|min:4|max:50',
            'email' => 'required|email|unique:users,email',
            'password' => 'required|string|min:8|password|confirmed',
        ]);

        dd($input); // Dump the validated input
    }
}

Combining Route Parameters and Dependency Injection

When your route has parameters, list them after injected dependencies:

Route definition:

Route::put('user/{id}', [UserController::class, 'update']);

Controller method implementation:

<?php

namespace App\Http\Controllers;

use Spark\Http\Request;

class UserController
{
    /**
     * Update the specified user.
     *
     * @param  Request  $request
     * @param  string  $id
     * @return Response
     */
    public function update(Request $request, $id)
    {
        // $id comes from route parameter
        // $request is injected automatically
    }
}

Best Practice: Use method injection for request-specific dependencies and constructor injection for dependencies needed across all controller methods.

Additional Injection Examples

You can combine multiple dependency types:

public function edit(
    Request $request,
    UserRepository $repository,
    $userId,
    ProfileService $profile
) {
    // $request - Injected
    // $repository - Injected
    // $userId - Route parameter
    // $profile - Injected
}