PHP code example of julienlinard / php-router

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

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

    

julienlinard / php-router example snippets

ulienLinard\Router\Router;
use JulienLinard\Router\Request;
use JulienLinard\Router\Response;
use JulienLinard\Router\Attributes\Route;

// Create a router instance
$router = new Router();

// Define a controller with routes
class HomeController
{
    #[Route(path: '/', methods: ['GET'], name: 'home')]
    public function index(): Response
    {
        return new Response(200, 'Welcome!');
    }
}

// Register routes
$router->registerRoutes(HomeController::class);

// Handle the request
$request = new Request();
$response = $router->handle($request);

// Send the response
$response->send();

namespace App\Controller;

use JulienLinard\Router\Attributes\Route;
use JulienLinard\Router\Request;
use JulienLinard\Router\Response;

class HomeController
{
    #[Route(path: '/', methods: ['GET'], name: 'home')]
    public function index(): Response
    {
        return new Response(200, 'Homepage');
    }
}

class ApiController
{
    #[Route(path: '/api/users', methods: ['GET'], name: 'api.users.index')]
    public function index(): Response
    {
        return Response::json(['users' => []]);
    }

    #[Route(path: '/api/users', methods: ['POST'], name: 'api.users.store')]
    public function store(Request $request): Response
    {
        $data = $request->getBody();
        // Process data...
        return Response::json(['message' => 'User created'], 201);
    }
}

$router = new Router();
$router->registerRoutes(HomeController::class);
$router->registerRoutes(ApiController::class);

use JulienLinard\Router\Middlewares\AuthMiddleware;

// Group with prefix only
$router->group('/api', [], function($router) {
    $router->registerRoutes(ApiController::class);
    // All routes will have the /api prefix
});

// Group with prefix and middlewares
$router->group('/admin', [AuthMiddleware::class], function($router) {
    $router->registerRoutes(AdminController::class);
    // All routes will have the /admin prefix AND the AuthMiddleware
});

// Nested groups
$router->group('/api', [], function($router) {
    $router->group('/v1', [], function($router) {
        $router->registerRoutes(ApiV1Controller::class);
        // Routes with /api/v1 prefix
    });
    
    $router->group('/v2', [], function($router) {
        $router->registerRoutes(ApiV2Controller::class);
        // Routes with /api/v2 prefix
    });
});

class ApiController
{
    // Path defined in controller: '/users'
    #[Route(path: '/users', methods: ['GET'], name: 'api.users.index')]
    public function index(): Response
    {
        return Response::json(['users' => []]);
    }
}

// Registration with group
$router->group('/api', [], function($router) {
    $router->registerRoutes(ApiController::class);
});

// The route will be accessible at: /api/users

class UserController
{
    #[Route(path: '/user/{id}', methods: ['GET'], name: 'user.show')]
    public function show(Request $request): Response
    {
        $userId = $request->getRouteParam('id');
        
        return Response::json([
            'user_id' => $userId,
            'message' => "Displaying user {$userId}"
        ]);
    }
}

class PostController
{
    #[Route(path: '/user/{userId}/post/{slug}', methods: ['GET'], name: 'post.show')]
    public function show(Request $request): Response
    {
        $userId = $request->getRouteParam('userId');
        $slug = $request->getRouteParam('slug');
        
        return Response::json([
            'user_id' => $userId,
            'slug' => $slug
        ]);
    }
}

// Get a specific parameter
$id = $request->getRouteParam('id');
$id = $request->getRouteParam('id', 'default'); // with default value

// Get all parameters
$params = $request->getRouteParams(); // ['id' => '123', 'slug' => 'my-article']

$request = new Request();

$path = $request->getPath();        // '/user/123'
$method = $request->getMethod();    // 'GET', 'POST', etc.

// URL: /search?q=php&page=2
$query = $request->getQueryParam('q');           // 'php'
$page = $request->getQueryParam('page', 1);      // '2' or 1 as default
$allParams = $request->getQueryParams();         // ['q' => 'php', 'page' => '2']

$contentType = $request->getHeader('content-type');
$allHeaders = $request->getHeaders();
$customHeader = $request->getHeader('x-custom-header', 'default');

$token = $request->getCookie('auth_token');
$allCookies = $request->getCookies();

// For JSON
$data = $request->getBody();                    // ['name' => 'John', 'email' => '...']
$name = $request->getBodyParam('name');         // 'John'
$rawBody = $request->getRawBody();              // Raw string

// For form-urlencoded
$data = $request->getBody();                    // ['field1' => 'value1', ...]

if ($request->isAjax()) {
    // AJAX request
}

if ($request->wantsJson()) {
    // Client accepts JSON
}

// Create a custom request for tests
$request = new Request('/user/123', 'GET');

$response = new Response(200, 'Response content');
$response->send();

$data = ['message' => 'Success', 'data' => []];
$response = Response::json($data, 200);
$response->send();

$response = new Response(200, 'Content');
$response->setHeader('X-Custom-Header', 'value');
$response->setHeader('Content-Type', 'application/xml');
$response->send();

$statusCode = $response->getStatusCode();    // 200
$content = $response->getContent();          // 'Content'
$headers = $response->getHeaders();         // ['content-type' => 'application/json']

use JulienLinard\Router\Router;
use JulienLinard\Core\Container\Container;

$router = new Router();
$container = new Container();

// Pass the Container to the Router
$router->setContainer($container);

// The Router will automatically use the Container to instantiate controllers

use JulienLinard\Router\Attributes\Route;
use JulienLinard\Router\Response;
use JulienLinard\Doctrine\EntityManager;
use JulienLinard\Auth\AuthManager;

class UserController
{
    private EntityManager $em;
    private AuthManager $auth;

    // Dependencies are automatically injected via the Container
    public function __construct(EntityManager $em, AuthManager $auth)
    {
        $this->em = $em;
        $this->auth = $auth;
    }

    #[Route(path: '/users', methods: ['GET'], name: 'users.index')]
    public function index(): Response
    {
        $users = $this->em->getRepository(User::class)->findAll();
        return Response::json($users);
    }
}

use JulienLinard\Router\Middlewares\CorsMiddleware;
use JulienLinard\Router\Middlewares\LoggingMiddleware;

$router = new Router();

// Add a global middleware
$router->addMiddleware(new CorsMiddleware());
$router->addMiddleware(new LoggingMiddleware());

use JulienLinard\Router\Middlewares\AuthMiddleware;
use JulienLinard\Router\Middlewares\RoleMiddleware;

class AdminController
{
    #[Route(
        path: '/admin/dashboard',
        methods: ['GET'],
        name: 'admin.dashboard',
        middleware: [AuthMiddleware::class, RoleMiddleware::class]
    )]
    public function dashboard(): Response
    {
        return new Response(200, 'Admin dashboard');
    }
}

use JulienLinard\Router\Middlewares\CorsMiddleware;

// Default configuration (all origins)
$cors = new CorsMiddleware();

// Custom configuration
$cors = new CorsMiddleware(
    allowedOrigins: ['https://example.com', 'https://app.example.com'],
    allowedMethods: ['GET', 'POST', 'PUT', 'DELETE'],
    allowedHeaders: ['Content-Type', 'Authorization'],
    allowCredentials: true
);

$router->addMiddleware($cors);

use JulienLinard\Router\Middlewares\AuthMiddleware;

class ProtectedController
{
    #[Route(
        path: '/profile',
        methods: ['GET'],
        middleware: [AuthMiddleware::class]
    )]
    public function profile(): Response
    {
        // User is authenticated
        return Response::json(['user' => $_SESSION['user']]);
    }
}

use JulienLinard\Router\Middlewares\RoleMiddleware;

class AdminController
{
    #[Route(
        path: '/admin/users',
        methods: ['GET'],
        middleware: [AuthMiddleware::class, RoleMiddleware::class]
    )]
    public function users(): Response
    {
        // User is authenticated AND has admin role
        return Response::json(['users' => []]);
    }
}

// In your bootstrap
$router->addMiddleware(new RoleMiddleware('admin'));

use JulienLinard\Router\Middlewares\LoggingMiddleware;

$router->addMiddleware(new LoggingMiddleware());
// Log all requests to error_log

namespace App\Middlewares;

use JulienLinard\Router\Middleware;
use JulienLinard\Router\Request;
use JulienLinard\Router\Response;

class CustomMiddleware implements Middleware
{
    public function handle(Request $request): void
    {
        // Your logic here
        // For example, check a condition
        
        if (/* condition not met */) {
            Response::json(['error' => 'Access denied'], 403)->send();
            exit;
        }
        
        // Otherwise, continue execution
    }
}

use JulienLinard\Router\ErrorHandler;

// Errors are automatically handled by the router
// You can use ErrorHandler directly if needed

$response = ErrorHandler::handleNotFound();      // 404
$response = ErrorHandler::handleServerError($e); // 500

$router->registerRoutes(HomeController::class);

$router->addMiddleware(new CorsMiddleware());

$response = $router->handle($request);

$routes = $router->getRoutes();
// ['static' => [...], 'dynamic' => [...]]

$route = $router->getRouteByName('home');
// ['path' => '/', 'method' => 'GET', 'route' => [...]]

// Static route
$url = $router->url('home');
// Returns: '/'

// Dynamic route with one parameter
$url = $router->url('user.show', ['id' => '123']);
// Returns: '/user/123'

// Dynamic route with multiple parameters
$url = $router->url('post.show', ['userId' => '123', 'slug' => 'my-article']);
// Returns: '/user/123/post/my-article'

// With query parameters
$url = $router->url('user.show', ['id' => '123'], ['page' => '2', 'sort' => 'name']);
// Returns: '/user/123?page=2&sort=name'

// Returns null if route doesn't exist
$url = $router->url('non-existent');
// Returns: null

// Throws exception if 

$router->group('/api', [AuthMiddleware::class], function($router) {
    $router->registerRoutes(ApiController::class);
});

new Response(int $statusCode = 200, string $content = '')

use JulienLinard\Core\Application;
use JulienLinard\Router\Attributes\Route;
use JulienLinard\Router\Response;

$app = Application::create(__DIR__);
$router = $app->getRouter();

class HomeController
{
    #[Route(path: '/', methods: ['GET'], name: 'home')]
    public function index(): Response
    {
        return new Response(200, '<h1>Home</h1>');
    }
}

$router->registerRoutes(HomeController::class);
$app->start();

use JulienLinard\Router\Router;
use JulienLinard\Router\Attributes\Route;
use JulienLinard\Router\Response;
use JulienLinard\Auth\AuthManager;
use JulienLinard\Auth\Middleware\AuthMiddleware;
use JulienLinard\Auth\Middleware\RoleMiddleware;

$router = new Router();
$auth = new AuthManager($authConfig);

class DashboardController
{
    #[Route(
        path: '/dashboard',
        methods: ['GET'],
        name: 'dashboard',
        middleware: [new AuthMiddleware($auth)]
    )]
    public function index(): Response
    {
        return new Response(200, '<h1>Dashboard</h1>');
    }
}

class AdminController
{
    #[Route(
        path: '/admin',
        methods: ['GET'],
        name: 'admin',
        middleware: [
            new AuthMiddleware($auth),
            new RoleMiddleware('admin', $auth)
        ]
    )]
    public function index(): Response
    {
        return new Response(200, '<h1>Admin</h1>');
    }
}

$router->registerRoutes(DashboardController::class);
$router->registerRoutes(AdminController::class);

ulienLinard\Router\Router;
use JulienLinard\Router\Attributes\Route;
use JulienLinard\Router\Request;
use JulienLinard\Router\Response;

$router = new Router();

class HomeController
{
    #[Route(path: '/', methods: ['GET'], name: 'home')]
    public function index(): Response
    {
        return new Response(200, 'Hello World');
    }
}

$router->registerRoutes(HomeController::class);

$request = new Request();
$response = $router->handle($request);
$response->send();

// In your views or controllers
$homeUrl = $router->url('home');
// Returns: '/'

$userUrl = $router->url('user.show', ['id' => '123']);
// Returns: '/user/123'

$url = $router->url('user.show', ['id' => '123'], ['page' => '2', 'sort' => 'name']);
// Returns: '/user/123?page=2&sort=name'

class UserController
{
    #[Route(path: '/user/{id}', methods: ['GET'], name: 'user.show')]
    public function show(Request $request, Router $router): Response
    {
        $id = $request->getRouteParam('id');
        
        // Generate next user URL
        $nextUserId = (int)$id + 1;
        $nextUrl = $router->url('user.show', ['id' => $nextUserId]);
        
        return Response::json([
            'user_id' => $id,
            'next_user_url' => $nextUrl
        ]);
    }
}

ulienLinard\Router\Router;
use JulienLinard\Router\Request;
use JulienLinard\Router\Response;
use JulienLinard\Router\Attributes\Route;
use JulienLinard\Router\Middlewares\CorsMiddleware;

class UserController
{
    // Paths are defined without the /api prefix (added by group)
    #[Route(path: '/users', methods: ['GET'], name: 'users.index')]
    public function index(): Response
    {
        return Response::json(['users' => []]);
    }

    #[Route(path: '/users/{id}', methods: ['GET'], name: 'users.show')]
    public function show(Request $request): Response
    {
        $id = $request->getRouteParam('id');
        return Response::json(['user' => ['id' => $id]]);
    }

    #[Route(path: '/users', methods: ['POST'], name: 'users.store')]
    public function store(Request $request): Response
    {
        $data = $request->getBody();
        // Create user...
        return Response::json(['message' => 'User created'], 201);
    }

    #[Route(path: '/users/{id}', methods: ['PUT'], name: 'users.update')]
    public function update(Request $request): Response
    {
        $id = $request->getRouteParam('id');
        $data = $request->getBody();
        // Update user...
        return Response::json(['message' => 'User updated']);
    }

    #[Route(path: '/users/{id}', methods: ['DELETE'], name: 'users.delete')]
    public function delete(Request $request): Response
    {
        $id = $request->getRouteParam('id');
        // Delete user...
        return Response::json(['message' => 'User deleted'], 204);
    }
}

// Configuration with groups
$router = new Router();
$router->addMiddleware(new CorsMiddleware());

// API group with /api prefix
$router->group('/api', [], function($router) {
    $router->registerRoutes(UserController::class);
});

// Processing
$request = new Request();
$response = $router->handle($request);
$response->send();

// URL generation
$usersUrl = $router->url('users.index');           // '/api/users'
$userUrl = $router->url('users.show', ['id' => 5]); // '/api/users/5'

ulienLinard\Router\Router;
use JulienLinard\Router\Request;
use JulienLinard\Router\Response;
use JulienLinard\Router\Attributes\Route;
use JulienLinard\Router\Middlewares\AuthMiddleware;
use JulienLinard\Router\Middlewares\RoleMiddleware;

class HomeController
{
    #[Route(path: '/', methods: ['GET'], name: 'home')]
    public function index(): Response
    {
        return new Response(200, '<h1>Welcome</h1>');
    }
}

class AuthController
{
    #[Route(path: '/login', methods: ['GET', 'POST'], name: 'login')]
    public function login(Request $request): Response
    {
        if ($request->getMethod() === 'POST') {
            // Process login
            $_SESSION['user'] = ['id' => 1, 'role' => 'user'];
            return new Response(302, '', ['Location' => '/dashboard']);
        }
        return new Response(200, '<form>...</form>');
    }
}

class DashboardController
{
    #[Route(
        path: '/dashboard',
        methods: ['GET'],
        name: 'dashboard',
        middleware: [AuthMiddleware::class]
    )]
    public function index(): Response
    {
        return new Response(200, '<h1>Dashboard</h1>');
    }
}

class AdminController
{
    #[Route(
        path: '/admin',
        methods: ['GET'],
        name: 'admin',
        middleware: [AuthMiddleware::class, RoleMiddleware::class]
    )]
    public function index(): Response
    {
        return new Response(200, '<h1>Admin</h1>');
    }
}

// Configuration with groups
$router = new Router();

// Public routes
$router->registerRoutes(HomeController::class);
$router->registerRoutes(AuthController::class);

// Dashboard group with authentication
$router->group('/dashboard', [AuthMiddleware::class], function($router) {
    $router->registerRoutes(DashboardController::class);
});

// Admin group with authentication and role
$router->group('/admin', [AuthMiddleware::class, new RoleMiddleware('admin')], function($router) {
    $router->registerRoutes(AdminController::class);
});

// Processing
session_start();
$request = new Request();
$response = $router->handle($request);
$response->send();

bash
composer