PHP code example of strictlyphp / dolphpin

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

strictlyphp / dolphpin example snippets

declare(strict_types=1);

namespace App\Controllers;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use StrictlyPHP\Dolphin\Attributes\Route;
use StrictlyPHP\Dolphin\Request\Method;
use StrictlyPHP\Dolphin\Response\JsonResponse;

#[Route(Method::POST, '/users')]
class CreateUserController
{
    public function __invoke(CreateUserDto $dto, ServerRequestInterface $request): ResponseInterface
    {
        // $dto is automatically mapped from the JSON body
        return new JsonResponse(['id' => '123', 'name' => $dto->name], 201);
    }
}

declare(strict_types=1);

namespace App\Controllers;

readonly class CreateUserDto
{
    public function __construct(
        public string $name,
        public EmailAddress $email,
    ) {
    }
}

use StrictlyPHP\Dolphin\App;

function main(array $event, object $context): array
{
    $app = App::build(
        controllers: ['App\Controllers'],
    );

    return $app->run($event, $context);
}

#[Route(Method::GET, '/users/{id}')]
class GetUserController { /* ... */ }

#[Route(Method::DELETE, '/users/{id}')]
class DeleteUserController { /* ... */ }

#[Route(Method::POST, '/admin/settings')]
#[RequiresRoles(['ADMIN'])]
class UpdateSettingsController { /* ... */ }

use StrictlyPHP\Dolphin\Authentication\AuthenticatedUserInterface;

class AuthMiddleware implements MiddlewareInterface
{
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $user = // ... resolve authenticated user
        $request = $request->withAttribute('user', $user);
        return $handler->handle($request);
    }
}

#[RequiresRoles([UserRole::ADMIN, 'SUPPORT'])]
class UpdateSettingsController { /* ... */ }

#[RequiresRole(UserRole::ADMIN)]
#[RequiresRole(UserRole::SUPPORT)]   // ADMIN or SUPPORT
class UpdateSettingsController { /* ... */ }

use StrictlyPHP\Dolphin\Authorization\PermissionInterface;
use StrictlyPHP\Dolphin\Authorization\RoleInterface;

enum UserKind: string implements RoleInterface
{
    case USER = 'USER';
    case ADMIN = 'ADMIN';
}

enum AdminPermission: string implements PermissionInterface
{
    case CREATE_REPORT = 'CREATE_REPORT';
    case DELETE_REPORT = 'DELETE_REPORT';
}

use StrictlyPHP\Dolphin\Authorization\AuthorizationServiceInterface;

$app = App::build(
    controllers: ['App\Controllers'],
    containerDefinitions: [
        AuthorizationServiceInterface::class => fn() => new MyAuthorizationService(),
    ],
    middlewares: [AuthMiddleware::class], // sets the 'user' request attribute
);

#[Route(Method::POST, '/reports')]
#[RequiresPermission(UserKind::ADMIN, AdminPermission::CREATE_REPORT)]
class CreateReportController { /* ... */ }

#[RequiresPermission(UserKind::ADMIN, AdminPermission::DELETE_REPORT)]
#[RequiresPermission(UserKind::USER, UserPermission::DELETE_REPORT)]
class DeleteReportController { /* ... */ }

#[Route(Method::POST, '/reports')]
#[RequiresPermission(UserKind::USER, UserPermission::CREATE_REPORT)]
#[AllowsRole(UserKind::ADMIN)]
class CreateReportController { /* ... */ }

// ADMIN                       -> allowed (no permission check)
// USER with CREATE_REPORT     -> allowed
// USER without CREATE_REPORT  -> 403

$app = App::build(
    controllers: ['App\Controllers'],
    containerDefinitions: [
        UserRepository::class => fn() => new UserRepository($db),
    ],
);

$app = App::build(
    controllers: ['App\Controllers'],
    middlewares: [AuthMiddleware::class, CorsMiddleware::class],
);

$app = App::build(
    controllers: ['App\Controllers'],
    debugMode: true,
);

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

class CustomErrorHandler implements MiddlewareInterface
{
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        try {
            return $handler->handle($request);
        } catch (\Throwable $e) {
            // Your custom error handling logic
            $response = (new \Slim\Psr7\Factory\ResponseFactory())->createResponse(500);
            $response->getBody()->write(json_encode(['error' => $e->getMessage()]));
            return $response->withHeader('Content-Type', 'application/json');
        }
    }
}

$app = App::build(
    controllers: ['App\Controllers'],
    throwableHandler: new CustomErrorHandler(),
);

$app = App::build(
    controllers: ['App\Controllers'],
    throwableHandler: new CustomErrorHandler(),        // route-level errors (PSR-15)
    exceptionHandler: function (\Throwable $e): ?array {  // app-level safety net
        \Sentry\captureException($e);
        return null; // use default error response
    },
);

use StrictlyPHP\Dolphin\Response\JsonResponse;

return new JsonResponse(['key' => 'value']);           // 200
return new JsonResponse(['created' => true], 201);     // 201