What is ADR?

Action — Domain — Responder

A complete example

A user makes a GET request to /path. Here is the full journey through each layer.

1. Define the route

$router->get('/path', Actions\Path\Index::class);

Every feature is a directory, and each route is its own operation inside it: Actions\Path\Index lives at app/Actions/Path/Index.php. A second route means a second class beside it, never a second method.

2. The Action receives the request

namespace Actions\Path;

use Actions\Action;
use Domains\Path\Index as IndexDomain;
use Responders\Path\Index as IndexResponder;
use TetherPHP\framework\Http\Response;
use TetherPHP\framework\Interfaces\ActionInterface;
use TetherPHP\framework\Requests\Request;

class Index extends Action implements ActionInterface
{
    public function __construct(protected Request $request)
    {
        $this->domain = new IndexDomain();
        $this->responder = new IndexResponder($request);
    }

    public function __invoke(): Response
    {
        return $this->respond($this->domain->handle());
    }
}

The Action is thin by design. It wires the Domain to the Responder and nothing more.

3. The result the Domain returns

namespace Domains\Path\Results;

use TetherPHP\framework\Interfaces\DomainResult;

final readonly class Page implements DomainResult
{
    public function __construct(
        public string $name,
        public string $description,
    ) {
    }
}

A value object, named in the Domain's terms. DomainResult is an empty marker interface — it exists so the pipeline has a type to state.

4. The Domain handles the logic

namespace Domains\Path;

use Domains\Domain;
use Domains\Path\Results\Page;

class Index extends Domain
{
    public function handle(): Page
    {
        return new Page(
            name: 'Path Domain',
            description: 'This is where business logic lives.',
        );
    }
}

The Domain has no knowledge of HTTP, views, or responses — and now no knowledge of what a template calls things either.

5. The Responder formats the output

namespace Responders\Path;

use Domains\Path\Results\Page;
use Responders\Responder;
use TetherPHP\framework\Http\Response;

class Index extends Responder
{
    public function __invoke(Page $result): Response
    {
        return $this->view('pages.path.index', [
            'heading' => $result->name,
            'blurb' => $result->description,
        ]);
    }
}

The Responder names every variable the view will read. It could just as easily return JSON.