PHPackages                             bobbynarvy/highway - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [HTTP & Networking](/categories/http)
4. /
5. bobbynarvy/highway

ActiveLibrary[HTTP & Networking](/categories/http)

bobbynarvy/highway
==================

Simple routing for PHP. PSR-7 and PSR-15 compatible.

0.5.0(7y ago)8481[1 issues](https://github.com/bobbynarvy/highway/issues)[1 PRs](https://github.com/bobbynarvy/highway/pulls)MITPHPPHP ^7.1CI failing

Since Oct 11Pushed 3mo ago2 watchersCompare

[ Source](https://github.com/bobbynarvy/highway)[ Packagist](https://packagist.org/packages/bobbynarvy/highway)[ RSS](/packages/bobbynarvy-highway/feed)WikiDiscussions master Synced 4d ago

READMEChangelog (1)Dependencies (6)Versions (4)Used By (0)

Highway
=======

[](#highway)

[![Build Status](https://camo.githubusercontent.com/362884811425b645b68f79e39e4de9b2fcd0347795d0e71edc0eb8c1c798fbe9/68747470733a2f2f7472617669732d63692e6f72672f626f6262796e617276792f686967687761792e7376673f6272616e63683d6d6173746572)](https://travis-ci.org/bobbynarvy/highway)

Simple routing for PHP. PSR-7 and PSR-15 compatible.

**Highway** is a component for routing HTTP requests to their handlers.

Install
-------

[](#install)

Via Composer

```
$ composer require bobbynarvy/highway
```

Usage
-----

[](#usage)

**Highway** can be used as a stand-alone router that can be integrated in any PHP script as well as a PSR-15 middleware.

### Basic usage: As a stand-alone router

[](#basic-usage-as-a-stand-alone-router)

A basic scenario where the router is used would look like:

```
// on index.php...

use Highway\{Route, Router};

// PSR-7 and PSR-15 interfaces
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Http\Message\ResponseInterface;

// Implementations of PSR-7 and PSR-15
use Zend\Diactoros\Response\HtmlResponse;
use Zend\Diactoros\{ServerRequestFactory, Response};
use Zend\HttpHandlerRunner\Emitter\SapiEmitter;

// Create an instance of PSR-7 ServerRequestInterface object
// using Zend\Diactoros
$request = ServerRequestFactory::fromGlobals(
    $_SERVER,
    $_GET,
    $_POST,
    $_COOKIE,
    $_FILES
);

// Create a new instance of Highway\Router
$router = new Router;

// Set the handler for HTTP requests going to the root path
$router->get("/", function (ServerRequestInterface $request) {
    // Return an instance of HtmlResponse, an implementation of
    // Psr\Http\Message\ResponseInterface;
    return new HtmlResponse("It works!");
});

// Set the handler for a route with parameters
$router->get("/users/{id}/messages/{num}", function (ServerRequestInterface $request) {
    // Assign the attributes to their respective variables using the
    // getAttribute() method of Psr\Http\Message\ServerRequestInterface
    $id = $request->getAttribute("id");
    $num = $request->getAttribute("num");

    return new HtmlResponse("ID: $id NUM: $num");
});

// Get the response to the request that matches a defined route
$response = $router->match($request)->handle($request);

// Emit the response to the HTTP client
$emitter = new SapiEmitter;
$emitter->emit($response);
```

*Note: The example above assumes that URL rewrites are enabled to remove 'index.php' from the URI*

### Methods

[](#methods)

To register routes, the router can be used with the fellowing methods that correspond to their HTTP methods

```
$router->get($path, $handler);
$router->post($path, $handler);
$router->put($path, $handler);
$router->patch($path, $handler);
$router->delete($path, $handler);
$router->options($path, $handler);
```

Multiple HTTP methods can also be mapped to respond the same way. For example:

```
$router->map(["GET", "POST"], $handler);
```

### Route prefixing

[](#route-prefixing)

The router can be used to prefix routes with a given path:

```
$router->with("/users/{id}", function(Router $router) {
    // will respond to /users/{id}/likes routes
    $router->get("/likes", $likeHandler);

    // will respond to /users/{id}/friends/{fid} routes
    $router->get("/friends/{fid}", $friendHandler);
});
```

### Handlers

[](#handlers)

Handlers are passed to the router along with a route. They define actions that are dispatched when the router finds a route that matches the request.

#### Closures

[](#closures)

A handler can be defined through a closure that takes an an object implementing [PSR-7 ServerRequestInterface](https://www.php-fig.org/psr/psr-7/#321-psrhttpmessageserverrequestinterface) and returns an object implementing [PSR-7 ResponseInterface](https://www.php-fig.org/psr/psr-7/#33-psrhttpmessageresponseinterface)

```
use Zend\Diactoros\Response\HtmlResponse;

$handler = function (ServerRequestInterface $request) {
    // return an instance of HtmlResponse, an implementation of
    // Psr\Http\Message\ResponseInterface;
    return new HtmlResponse("It works!");
}
```

#### PSR-15 RequestHandlerInterface

[](#psr-15-requesthandlerinterface)

A handler can be defined using an object that implements the [PSR-15 RequestHandlerInterface](https://www.php-fig.org/psr/psr-15/#21-psrhttpserverrequesthandlerinterface)

```
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Zend\Diactoros\Response\HtmlResponse;

$handler = new class implements RequestHandlerInterface {
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        return new HtmlResponse("It works!");
    }
};
```

#### Request parameters

[](#request-parameters)

Request parameters can be accessed using the `getAttribute` method of a *PSR-7 ServerRequestInterface* object:

```
$router->get("/users/{id}/messages/{num}", function (ServerRequestInterface $request) {
    $id = $request->getAttribute("id");
    /* ... */
});
```

### As a PSR-15 Middleware

[](#as-a-psr-15-middleware)

**Highway** can be used to create a PSR-15 compliant middleware. Unlike other router implementations, which themselves assign and dispatch middlewares, **Highway** itself *is* a middleware!

```
/*...*/
use Highway\{Router, RouterMiddleware};
use Zend\Diactoros\Response\HtmlResponse;
/*...*/

$routerMiddleware = RouterMiddleware::create(function (Router $router) {
    $router->get("/", function (ServerRequestInterface $request) {
        return new HtmlResponse("It works!");
    });
    /* ... */
});
```

**Highway** can then be used alongside other reusable PSR-15 middlewares. Using the [`middlewares/utils`](https://github.com/middlewares/utils#dispatcher) Dispatcher, for example:

```
/*...*/
use Middlewares\Utils\Dispatcher;
/*...*/

$routerMiddleware =  RouterMiddleware::create(function (Router $router) {
    // define routes...
});

$response = Dispatcher::run([
    $someAuthMiddleware,
    $someLoggingMiddleware,
    $routerMiddleware
]);
```

Testing
-------

[](#testing)

```
$ composer test {file or path to test}
```

Credits
-------

[](#credits)

- [Robert Narvaez](https://github.com/bobbynarvy)

License
-------

[](#license)

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

###  Health Score

33

↑

LowBetter than 75% of packages

Maintenance51

Moderate activity, may be stable

Popularity14

Limited adoption so far

Community11

Small or concentrated contributor base

Maturity49

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 96% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

2765d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/12933200?v=4)[Robert Narvaez](/maintainers/bobbynarvy)[@bobbynarvy](https://github.com/bobbynarvy)

---

Top Contributors

[![bobbynarvy](https://avatars.githubusercontent.com/u/12933200?v=4)](https://github.com/bobbynarvy "bobbynarvy (24 commits)")[![fizk](https://avatars.githubusercontent.com/u/386336?v=4)](https://github.com/fizk "fizk (1 commits)")

---

Tags

psr-15psr-7routerroutinghttprouterrouting

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/bobbynarvy-highway/health.svg)

```
[![Health](https://phpackages.com/badges/bobbynarvy-highway/health.svg)](https://phpackages.com/packages/bobbynarvy-highway)
```

###  Alternatives

[sunrise/http-router

A powerful solution as the foundation of your project.

16249.8k10](/packages/sunrise-http-router)[miladrahimi/phprouter

A powerful, lightweight, and very fast HTTP URL router for PHP projects.

20832.6k2](/packages/miladrahimi-phprouter)[mezzio/mezzio-authentication-oauth2

OAuth2 (server) authentication middleware for Mezzio and PSR-7 applications.

28483.0k2](/packages/mezzio-mezzio-authentication-oauth2)[openswoole/core

Openswoole core library

181.1M32](/packages/openswoole-core)[mezzio/mezzio-authentication

Authentication middleware for Mezzio and PSR-7 applications

121.6M26](/packages/mezzio-mezzio-authentication)[wilaak/radix-router

High-performance radix tree based HTTP request router

612.8k5](/packages/wilaak-radix-router)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)