PHP code example of zephyrus-framework / core

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

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

    

zephyrus-framework / core example snippets

use Zephyrus\Core\ApplicationBuilder;
use Zephyrus\Core\Config\Configuration;
use Zephyrus\Http\Request;
use Zephyrus\Routing\Router;
use Zephyrus\Security\AllowedHostsMiddleware;
use Zephyrus\Security\CsrfConfig;
use Zephyrus\Security\CsrfMiddleware;
use Zephyrus\Security\SecureHeadersMiddleware;
use Zephyrus\Session\SessionCsrfTokenManager;
use Zephyrus\Session\SessionManager;
use Zephyrus\Session\SessionMiddleware;

$configuration = Configuration::fromYamlFile(__DIR__ . '/../config.yml');

$router = (new Router())
    ->discoverControllers('App\\Controllers', __DIR__ . '/../app/Controllers');

$session = new SessionManager();
$csrf = new SessionCsrfTokenManager($session);

$builder = ApplicationBuilder::create()
    ->withConfiguration($configuration)
    ->withRouter($router)
    ->withMiddleware(new SecureHeadersMiddleware($configuration->security->headers))
    ->withMiddleware(new AllowedHostsMiddleware($configuration->security->allowedHosts))
    ->withMiddleware(new SessionMiddleware($configuration->session, $session))
    ->withMiddleware(new CsrfMiddleware($csrf, CsrfConfig::fromSecurityConfig($configuration->security)));

$application = $builder->build();
$application->handle(Request::fromGlobals())->send();

$builder = $builder->withAcknowledgedSecurityKeys(['forceHttps']);

$debugSecret = getenv('DEBUG_SECRET');
if (is_string($debugSecret) && $debugSecret !== '') {
    $builder = $builder->withDebugClientAllowlist($debugSecret . '@172.17.0.1');
}

use Zephyrus\Core\Config\ConfigSection;
use Zephyrus\Core\Config\Configuration;

final class NewsletterConfig extends ConfigSection
{
    public readonly string $sender;

    public static function fromArray(array $values): static
    {
        $instance = new static($values);
        $instance->sender = $instance->getString('sender');

        return $instance;
    }
}

$configuration = Configuration::fromYamlFile(__DIR__ . '/../config.yml', [
    'newsletter' => NewsletterConfig::class,
]);
$newsletter = $configuration->section('newsletter'); // a NewsletterConfig

use Zephyrus\Controller\Controller;
use Zephyrus\Routing\Attribute\Get;
use Zephyrus\Routing\Attribute\Post;
use Zephyrus\Http\Request;
use Zephyrus\Http\Response;

class UserController extends Controller
{
    #[Get('/users')]
    public function index(): Response
    {
        return Response::json(['users' => []]);
    }

    #[Get('/users/{id}')]
    public function show(int $id): Response
    {
        return Response::json(['id' => $id]);
    }

    #[Post('/users')]
    public function store(Request $request): Response
    {
        $data = $request->body()->all();
        return Response::json(['created' => true], 201);
    }
}

use Zephyrus\Routing\Route;

$router = $router->get('/docs/{slug}', 'DocController@show', ['slug' => Route::SAFE_SLUG]);

use Zephyrus\Controller\Controller;
use Zephyrus\Http\Response;
use Zephyrus\Routing\Attribute\Get;
use Zephyrus\Routing\Attribute\Root;

#[Root('/admin')]
class AdminController extends Controller {}

#[Root('/users')]
class AdminUserController extends AdminController
{
    #[Get('/list')]  // resolves to /admin/users/list
    public function list(): Response
    {
        return Response::text('Admin users');
    }
}

$router = $router->discoverControllers('App\\Controllers', __DIR__ . '/../app/Controllers');

use Zephyrus\Http\MiddlewareInterface;
use Zephyrus\Http\Request;
use Zephyrus\Http\Response;

final class RequestIdMiddleware implements MiddlewareInterface
{
    public function process(Request $request, callable $next): Response
    {
        return $next($request)->withHeader('X-Request-Id', bin2hex(random_bytes(8)));
    }
}

use Zephyrus\Security\AuthGuardMiddleware;
use Zephyrus\Security\HeaderTokenGuard;

$apiToken = getenv('API_TOKEN') ?: throw new \RuntimeException('API_TOKEN is not set');
$builder = $builder->registerMiddleware('auth', new AuthGuardMiddleware(new HeaderTokenGuard($apiToken)));

use Zephyrus\Controller\Controller;
use Zephyrus\Http\Response;
use Zephyrus\Routing\Attribute\Middleware;
use Zephyrus\Routing\Attribute\Post;

#[Middleware('auth')]
class ItemApiController extends Controller
{
    #[Post('/api/items')]
    public function store(): Response
    {
        return Response::json(['created' => true], 201);
    }
}

use Zephyrus\Controller\Controller;
use Zephyrus\Http\Response;
use Zephyrus\Routing\Attribute\Get;
use Zephyrus\Routing\Attribute\WithoutMiddleware;
use Zephyrus\Session\SessionMiddleware;

class PricingController extends Controller
{
    #[Get('/pricing')]
    #[WithoutMiddleware(SessionMiddleware::class)]
    public function show(): Response
    {
        return Response::html('<h1>Pricing</h1>');
    }
}

use Zephyrus\Session\SessionMiddleware;

$router = $router
    ->get('/pricing', 'PricingController@show')
    ->withoutMiddleware(SessionMiddleware::class);

use Zephyrus\Routing\Router;
use Zephyrus\Session\SessionMiddleware;

$router = $router->group('/public', fn (Router $r) => $r
    ->get('/pricing', 'PricingController@show')
    ->get('/faq', 'FaqController@show'),
    excludedMiddlewares: [SessionMiddleware::class],
);

<input type="hidden" name="_csrf_token" value="<?= htmlspecialchars($csrf->getToken(), ENT_QUOTES, 'UTF-8') 

use Zephyrus\Http\Request;
use Zephyrus\Http\Response;
use Zephyrus\Security\CsrfConfig;
use Zephyrus\Security\CsrfFailure;
use Zephyrus\Security\CsrfMiddleware;

$csrfMiddleware = new CsrfMiddleware(
    $csrf,
    CsrfConfig::fromSecurityConfig($configuration->security),
    onFailure: static fn (Request $request, CsrfFailure $failure): ?Response => $request->path() === '/login'
        ? Response::redirect('/login?expired=1')
        : null,
);

$request->uri();      // scheme, host, path, query string
$request->body();     // POST/JSON body (RequestBody: get(key), all(), has(key))
$request->headers();  // HeaderBag: get(name), bearerToken(), isJson()
$request->cookies();  // CookieJar: get(name), all()
$request->query;      // query string parameters (array)
$request->files;      // uploaded files

use Zephyrus\Http\Response;

Response::json(['key' => 'value']);
Response::json($data, 201);
Response::redirect('/login');
Response::localRedirect($request->query['next'] ?? '/'); // a target from the request: local paths only
Response::html('<p>Hello</p>');
Response::text('OK');

use Zephyrus\Validation\FormValidator;
use Zephyrus\Validation\Rules;

$form = new FormValidator([
    'email' => [Rules::ption, answered with a 422
$this->validate($form, $request->body()->all());

use Zephyrus\Data\Database;
use Zephyrus\Session\DatabaseSessionHandler;

$databaseConfig = $configuration->database
    ?? throw new \LogicException('Database sessions need a database: section in config.yml');

$session->setHandler(new DatabaseSessionHandler(fn (): Database => Database::fromConfig($databaseConfig), 'core.session'));

bash
XDEBUG_MODE=coverage php vendor/bin/phpunit --coverage-text