Contract Interfaces (Slim\Interfaces\*)

The Slim\Interfaces namespace (17 interfaces across 17 files in Slim/Interfaces/) defines the complete architectural contract surface of Slim Framework v4.15.3. Every subsystem—PSR-17 factory auto-discovery, container-aware callable resolution, LIFO PSR-15 middleware dispatching, FastRoute regex routing, route invocation strategies, and content-negotiated error rendering—is decoupled behind a dedicated interface so applications can swap any default implementation via AppFactory or a PSR-11 DI container.

from drawlib.canvas import save, setup
from drawlib.icons import phosphor
from drawlib.smartarts import CardList, Panel
from drawlib.styles import Colors, Styles

setup(width=196, height=90, dpi=150)

# Left Panel: Routing & FastRoute Dispatching Contracts (7 Interfaces)
p_left = Panel(
    "Routing & Dispatching Contracts (7)",
    "",
    style=Styles.Neutral.patch(shape_r=2.0),
    header_style=Styles.PrimaryNeutral.patch(shape_line_width=1.2),
    text_style=Styles.DarkBold.patch(text_size=11.0),
    icon=phosphor.git_branch,
    icon_style=Styles.PrimaryBold,
    header_variant="filled",
    header_height=8.6,
)
p_left.draw((4.0, 4.0), width=92.0, height=82.0)
lx, lw, lh = p_left.get_content_box((4.0, 4.0), width=92.0, height=82.0, padding=(3.5, 3.0))

cl_left = CardList(
    style=Styles.White,
    text_style=Styles.DarkBold.patch(text_size=10.5),
    description_style=Styles.Dark.patch(text_size=10.0),
    badge_shape="rounded_rect",
    badge_style=Styles.PrimaryNeutral,
    badge_text_style=Styles.PrimaryBold.patch(text_size=10.0),
    icon_style=Styles.PrimaryBold,
    direction="vertical",
    spacing=2.6,
    show_arrows=True,
    arrow_style=Styles.DarkBold.patch(line_arrow_head_scale=10, line_width=1.4),
)
cl_left.add(
    "RouteCollectorProxy & RouteCollector",
    "HTTP verb registration (get/post/map/group)",
    badge_text="R1",
    icon=phosphor.compass,
    style=Styles.PrimaryFlat,
    text_style=Styles.WhiteBold.patch(text_size=10.5),
    description_style=Styles.White.patch(text_size=10.0),
    badge_style=Styles.White,
    badge_text_style=Styles.PrimaryBold.patch(text_size=10.0),
    icon_style=Styles.PrimaryBold,
)
cl_left.add(
    "RouteInterface & RouteGroupInterface",
    "Per-route & group middleware stacks + run()",
    badge_text="R2",
    icon=phosphor.brackets_curly,
    style=Styles.PrimaryNeutral,
)
cl_left.add(
    "RouteParserInterface",
    "Reverse URL generation (relativeUrlFor/urlFor)",
    badge_text="R3",
    icon=phosphor.link,
)
cl_left.add(
    "RouteResolver & DispatcherInterface",
    "FastRoute URI matching -> RoutingResults",
    badge_text="R4",
    icon=phosphor.lightning,
    style=Styles.SecondaryNeutral,
    badge_style=Styles.White.patch(shape_line_color=Colors.Gray4),
    badge_text_style=Styles.DarkBold.patch(text_size=10.0),
)
cl_left.draw(xy=lx, width=lw, height=lh)

# Right Panel: PSR-17, Callable, Middleware & Error Contracts (10 Interfaces)
p_right = Panel(
    "PSR-17, Callable, Middleware & Error (10)",
    "",
    style=Styles.Neutral.patch(shape_r=2.0),
    header_style=Styles.SecondaryNeutral.patch(shape_line_width=1.2),
    text_style=Styles.DarkBold.patch(text_size=11.0),
    icon=phosphor.plugs_connected,
    icon_style=Styles.SecondaryBold,
    header_variant="filled",
    header_height=8.6,
)
p_right.draw((100.0, 4.0), width=92.0, height=82.0)
rx, rw, rh = p_right.get_content_box((100.0, 4.0), width=92.0, height=82.0, padding=(3.5, 3.0))

cl_right = CardList(
    style=Styles.White,
    text_style=Styles.DarkBold.patch(text_size=10.5),
    description_style=Styles.Dark.patch(text_size=10.0),
    badge_shape="rounded_rect",
    badge_style=Styles.SecondaryNeutral,
    badge_text_style=Styles.DarkBold.patch(text_size=10.0),
    icon_style=Styles.SecondaryBold,
    direction="vertical",
    spacing=2.6,
)
cl_right.add(
    "Psr17Factory, Provider & RequestCreator",
    "Auto-detect PSR-17 factories & globals creator",
    badge_text="P17",
    icon=phosphor.factory,
)
cl_right.add(
    "CallableResolver & AdvancedCallable",
    "Resolve 'Class:method' & DI service callables",
    badge_text="DI",
    icon=phosphor.code,
    style=Styles.PrimaryNeutral,
)
cl_right.add(
    "MiddlewareDispatcher & Strategies",
    "LIFO PSR-15 stack & 2 invocation contracts",
    badge_text="P15",
    icon=phosphor.stack,
    style=Styles.AccentFlat,
    text_style=Styles.WhiteBold.patch(text_size=10.5),
    description_style=Styles.White.patch(text_size=10.0),
    badge_style=Styles.White,
    badge_text_style=Styles.DarkBold.patch(text_size=10.0),
    icon_style=Styles.SecondaryBold,
)
cl_right.add(
    "ErrorHandler & ErrorRendererInterface",
    "Exception -> PSR-7 Response & MIME payload",
    badge_text="Err",
    icon=phosphor.shield_warning,
    style=Styles.SecondaryNeutral,
    badge_style=Styles.White.patch(shape_line_color=Colors.Gray4),
    badge_text_style=Styles.DarkBold.patch(text_size=10.0),
)
cl_right.draw(xy=rx, width=rw, height=rh)

save()

Summary Matrix of All 17 Slim\Interfaces\* Contracts#

from drawlib.canvas import save, setup
from drawlib.icons import phosphor
from drawlib.smartarts import CardList, Panel
from drawlib.styles import Colors, Styles

setup(width=196, height=84, dpi=150)

# Left Panel: 3 Specialized Sub-Interface Extensions
p_left = Panel(
    "Contract Inheritance Extensions (3 Pairs)",
    "",
    style=Styles.Neutral.patch(shape_r=2.0),
    header_style=Styles.PrimaryNeutral.patch(shape_line_width=1.2),
    text_style=Styles.DarkBold.patch(text_size=11.0),
    icon=phosphor.git_fork,
    icon_style=Styles.PrimaryBold,
    header_variant="filled",
    header_height=8.6,
)
p_left.draw((4.0, 4.0), width=92.0, height=76.0)
lx, lw, lh = p_left.get_content_box((4.0, 4.0), width=92.0, height=76.0, padding=(3.5, 3.0))

cl_left = CardList(
    style=Styles.White,
    text_style=Styles.DarkBold.patch(text_size=10.5),
    description_style=Styles.Dark.patch(text_size=10.0),
    badge_shape="rounded_rect",
    badge_style=Styles.PrimaryNeutral,
    badge_text_style=Styles.PrimaryBold.patch(text_size=10.0),
    icon_style=Styles.PrimaryBold,
    direction="vertical",
    spacing=2.8,
)
cl_left.add(
    "MiddlewareDispatcherInterface",
    "Extends PSR-15 RequestHandlerInterface",
    badge_text="P15",
    icon=phosphor.stack,
    style=Styles.PrimaryFlat,
    text_style=Styles.WhiteBold.patch(text_size=10.5),
    description_style=Styles.White.patch(text_size=10.0),
    badge_style=Styles.White,
    badge_text_style=Styles.PrimaryBold.patch(text_size=10.0),
    icon_style=Styles.PrimaryBold,
)
cl_left.add(
    "AdvancedCallableResolverInterface",
    "Extends CallableResolverInterface (+2 methods)",
    badge_text="DI",
    icon=phosphor.plugs_connected,
    style=Styles.PrimaryNeutral,
)
cl_left.add(
    "RequestHandlerInvocationStrategy",
    "Marker extending InvocationStrategyInterface",
    badge_text="Tag",
    icon=phosphor.tag,
)
cl_left.draw(xy=lx, width=lw, height=lh)

# Right Panel: Default Kernel Wiring in App::__construct()
p_right = Panel(
    "App::__construct() Default Contract Wiring",
    "",
    style=Styles.Neutral.patch(shape_r=2.0),
    header_style=Styles.SecondaryNeutral.patch(shape_line_width=1.2),
    text_style=Styles.DarkBold.patch(text_size=11.0),
    icon=phosphor.gear,
    icon_style=Styles.SecondaryBold,
    header_variant="filled",
    header_height=8.6,
)
p_right.draw((100.0, 4.0), width=92.0, height=76.0)
rx, rw, rh = p_right.get_content_box((100.0, 4.0), width=92.0, height=76.0, padding=(3.5, 3.0))

cl_right = CardList(
    style=Styles.White,
    text_style=Styles.DarkBold.patch(text_size=10.5),
    description_style=Styles.Dark.patch(text_size=10.0),
    badge_shape="rounded_rect",
    badge_style=Styles.SecondaryNeutral,
    badge_text_style=Styles.DarkBold.patch(text_size=10.0),
    icon_style=Styles.SecondaryBold,
    direction="vertical",
    spacing=2.8,
    show_arrows=True,
    arrow_style=Styles.DarkBold.patch(line_arrow_head_scale=10, line_width=1.4),
)
cl_right.add(
    "CallableResolverInterface",
    "Defaults to new CallableResolver(container)",
    badge_text="W1",
    icon=phosphor.code,
)
cl_right.add(
    "RouteCollector & RouteResolverInterface",
    "Defaults to RouteCollector + RouteResolver",
    badge_text="W2",
    icon=phosphor.compass,
    style=Styles.SecondaryNeutral,
)
cl_right.add(
    "MiddlewareDispatcherInterface",
    "Seeded with RouteRunner -> wraps PSR-15 onion",
    badge_text="W3",
    icon=phosphor.play_circle,
    style=Styles.AccentFlat,
    text_style=Styles.WhiteBold.patch(text_size=10.5),
    description_style=Styles.White.patch(text_size=10.0),
    badge_style=Styles.White,
    badge_text_style=Styles.DarkBold.patch(text_size=10.0),
    icon_style=Styles.SecondaryBold,
)
cl_right.draw(xy=rx, width=rw, height=rh)

save()

interfaceSlim\Interfaces\AdvancedCallableResolverInterface#

• Source File: Slim/Interfaces/AdvancedCallableResolverInterface.php
• Namespace: Slim\Interfaces
• Extends: Slim\Interfaces\CallableResolverInterface
• Default Implementation: Slim\CallableResolver
• Consumed By: Slim\MiddlewareDispatcher, Slim\Routing\Route, Slim\Routing\RouteGroup, Slim\Middleware\ErrorMiddleware, Slim\Handlers\ErrorHandler

Extends CallableResolverInterface with context-specific resolution methods (resolveRoute() and resolveMiddleware()). When a single class name or container service ID is passed without a :method suffix, CallableResolver uses resolveRoute() to look for handle() (PSR-15 RequestHandlerInterface) and resolveMiddleware() to look for process() (PSR-15 MiddlewareInterface).

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

interface AdvancedCallableResolverInterface extends CallableResolverInterface
{
    /**
     * Resolve $toResolve into a callable
     *
     * @param callable|array{class-string, string}|string $toResolve
     */
    public function resolveRoute($toResolve): callable;

    /**
     * Resolve $toResolve into a callable
     *
     * @param callable|array{class-string, string}|string $toResolve
     */
    public function resolveMiddleware($toResolve): callable;
}

Methods & Parameters#

Usage Example#

use Slim\CallableResolver;
use Slim\Interfaces\AdvancedCallableResolverInterface;

/** @var AdvancedCallableResolverInterface $resolver */
$resolver = new CallableResolver($container);

// Resolves a PSR-15 RequestHandlerInterface class string to [$instance, 'handle']:
$routeCallable = $resolver->resolveRoute(ShowUserAction::class);

// Resolves a PSR-15 MiddlewareInterface class string to [$instance, 'process']:
$middlewareCallable = $resolver->resolveMiddleware(AuthMiddleware::class);

interfaceSlim\Interfaces\CallableResolverInterface#

• Source File: Slim/Interfaces/CallableResolverInterface.php
• Namespace: Slim\Interfaces
• Extended By: Slim\Interfaces\AdvancedCallableResolverInterface
• Default Implementation: Slim\CallableResolver

Defines the base contract for resolving string notations ('Class:method', 'Class::method', or PSR-11 container service identifiers), ['Class', 'method'] tuples, or invokable classes into executable PHP callable instances.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

interface CallableResolverInterface
{
    /**
     * Resolve $toResolve into a callable
     *
     * @param callable|array{class-string, string}|string $toResolve
     */
    public function resolve($toResolve): callable;
}

Methods & Parameters#

Usage Example#

use Slim\CallableResolver;
use Slim\Interfaces\CallableResolverInterface;

/** @var CallableResolverInterface $resolver */
$resolver = new CallableResolver($container);

// Resolves Slim's 'Class:method' notation via container or `new HomeController()`:
$callable = $resolver->resolve('App\Controller\HomeController:index');

interfaceSlim\Interfaces\DispatcherInterface#

• Source File: Slim/Interfaces/DispatcherInterface.php
• Namespace: Slim\Interfaces
• Default Implementation: Slim\Routing\Dispatcher
• Consumed By: Slim\Routing\RouteResolver, Slim\Routing\RoutingResults

Defines the contract wrapping the underlying URL router (FastRoute's FastRouteDispatcher) to match an HTTP request method and URI path into a Slim\Routing\RoutingResults value object and inspect allowed HTTP methods for a given URI.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Slim\Routing\RoutingResults;

interface DispatcherInterface
{
    /**
     * Get routing results for a given request method and uri
     */
    public function dispatch(string $method, string $uri): RoutingResults;

    /**
     * Get allowed methods for a given uri
     *
     * @return string[]
     */
    public function getAllowedMethods(string $uri): array;
}

Methods & Parameters#

Usage Example#

use Slim\Interfaces\DispatcherInterface;
use Slim\Routing\Dispatcher;
use Slim\Routing\RoutingResults;

/** @var DispatcherInterface $dispatcher */
$dispatcher = new Dispatcher($routeCollector);

$results = $dispatcher->dispatch('GET', '/users/42');
if ($results->getRouteStatus() === RoutingResults::FOUND) {
    $routeId = $results->getRouteIdentifier();
    $args = $results->getRouteArguments(); // ['id' => '42']
}

interfaceSlim\Interfaces\ErrorHandlerInterface#

• Source File: Slim/Interfaces/ErrorHandlerInterface.php
• Namespace: Slim\Interfaces
• Default Implementation: Slim\Handlers\ErrorHandler
• Consumed By: Slim\Middleware\ErrorMiddleware

Defines the invokable contract for exception handlers registered with ErrorMiddleware. Any custom error handler class implementing ErrorHandlerInterface receives the active PSR-7 request, the caught \Throwable, and three boolean diagnostic flags, and returns a PSR-7 ResponseInterface.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Throwable;

interface ErrorHandlerInterface
{
    public function __invoke(
        ServerRequestInterface $request,
        Throwable $exception,
        bool $displayErrorDetails,
        bool $logErrors,
        bool $logErrorDetails
    ): ResponseInterface;
}

Methods & Parameters#

Usage Example#

use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Slim\Interfaces\ErrorHandlerInterface;
use Throwable;

final class CustomJsonErrorHandler implements ErrorHandlerInterface
{
    private ResponseFactoryInterface $responseFactory;

    public function __construct(ResponseFactoryInterface $responseFactory)
    {
        $this->responseFactory = $responseFactory;
    }

    public function __invoke(
        ServerRequestInterface $request,
        Throwable $exception,
        bool $displayErrorDetails,
        bool $logErrors,
        bool $logErrorDetails
    ): ResponseInterface {
        $response = $this->responseFactory->createResponse(500);
        $payload = ['error' => $displayErrorDetails ? $exception->getMessage() : 'Server Error'];
        $response->getBody()->write(json_encode($payload, JSON_THROW_ON_ERROR));
        return $response->withHeader('Content-Type', 'application/json');
    }
}

interfaceSlim\Interfaces\ErrorRendererInterface#

• Source File: Slim/Interfaces/ErrorRendererInterface.php
• Namespace: Slim\Interfaces
• Default Implementations: Slim\Error\AbstractErrorRenderer, Slim\Error\Renderers\JsonErrorRenderer, Slim\Error\Renderers\HtmlErrorRenderer, Slim\Error\Renderers\PlainTextErrorRenderer, Slim\Error\Renderers\XmlErrorRenderer
• Consumed By: Slim\Handlers\ErrorHandler

Defines the invokable contract for formatting a caught \Throwable into a serialized string body (HTML, JSON, XML, PlainText, or Problem Details) based on content negotiation inside ErrorHandler.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Throwable;

interface ErrorRendererInterface
{
    public function __invoke(Throwable $exception, bool $displayErrorDetails): string;
}

Methods & Parameters#

Usage Example#

use Slim\Interfaces\ErrorRendererInterface;
use Throwable;

final class ProblemDetailsJsonRenderer implements ErrorRendererInterface
{
    public function __invoke(Throwable $exception, bool $displayErrorDetails): string
    {
        return json_encode([
            'type' => 'https://example.com/probs/error',
            'title' => $exception->getMessage(),
            'status' => $exception->getCode() ?: 500,
        ], JSON_THROW_ON_ERROR);
    }
}

interfaceSlim\Interfaces\InvocationStrategyInterface#

• Source File: Slim/Interfaces/InvocationStrategyInterface.php
• Namespace: Slim\Interfaces
• Extended By: Slim\Interfaces\RequestHandlerInvocationStrategyInterface
• Default Implementations: Slim\Handlers\Strategies\RequestResponse (default), Slim\Handlers\Strategies\RequestResponseArgs, Slim\Handlers\Strategies\RequestResponseNamedArgs, Slim\Handlers\Strategies\RequestHandler
• Consumed By: Slim\Routing\RouteCollector, Slim\Routing\Route

Defines the strategy contract for invoking a matched route's callable with the PSR-7 ServerRequestInterface, ResponseInterface, and extracted FastRoute URI placeholder arguments (array<string, string>).

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

/**
 * Defines a contract for invoking a route callable.
 */
interface InvocationStrategyInterface
{
    /**
     * Invoke a route callable.
     *
     * @param callable               $callable       The callable to invoke using the strategy.
     * @param ServerRequestInterface $request        The request object.
     * @param ResponseInterface      $response       The response object.
     * @param array<string, string>  $routeArguments The route's placeholder arguments
     *
     * @return ResponseInterface The response from the callable.
     */
    public function __invoke(
        callable $callable,
        ServerRequestInterface $request,
        ResponseInterface $response,
        array $routeArguments
    ): ResponseInterface;
}

Methods & Parameters#

Usage Example#

use Slim\Handlers\Strategies\RequestResponseArgs;

// Switch the application's default route invocation strategy so route placeholders
// are unpacked as positional arguments: function ($request, $response, $id, $slug)
$routeCollector = $app->getRouteCollector();
$routeCollector->setDefaultInvocationStrategy(new RequestResponseArgs());

interfaceSlim\Interfaces\MiddlewareDispatcherInterface#

• Source File: Slim/Interfaces/MiddlewareDispatcherInterface.php
• Namespace: Slim\Interfaces
• Extends: Psr\Http\Server\RequestHandlerInterface
• Default Implementation: Slim\MiddlewareDispatcher
• Consumed By: Slim\App, Slim\Factory\AppFactory, Slim\Routing\Route

Defines the contract for Slim's Last-In-First-Out (LIFO) concentric PSR-15 middleware stack. Because it extends Psr\Http\Server\RequestHandlerInterface, any MiddlewareDispatcherInterface implementation also provides handle(ServerRequestInterface $request): ResponseInterface.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

/** @api */
interface MiddlewareDispatcherInterface extends RequestHandlerInterface
{
    /**
     * Add a new middleware to the stack
     *
     * Middleware are organized as a stack. That means middleware
     * that have been added before will be executed after the newly
     * added one (last in, first out).
     *
     * @param MiddlewareInterface|string|callable $middleware
     */
    public function add($middleware): self;

    /**
     * Add a new middleware to the stack
     *
     * Middleware are organized as a stack. That means middleware
     * that have been added before will be executed after the newly
     * added one (last in, first out).
     */
    public function addMiddleware(MiddlewareInterface $middleware): self;

    /**
     * Seed the middleware stack with the inner request handler
     */
    public function seedMiddlewareStack(RequestHandlerInterface $kernel): void;
}

Methods & Parameters#

Usage Example#

use Slim\Interfaces\MiddlewareDispatcherInterface;

/** @var MiddlewareDispatcherInterface $dispatcher */
$dispatcher = $app->getMiddlewareDispatcher();
$dispatcher->add(CorrelationIdMiddleware::class);

interfaceSlim\Interfaces\Psr17FactoryInterface#

• Source File: Slim/Interfaces/Psr17FactoryInterface.php
• Namespace: Slim\Interfaces
• Default Base Implementation: Slim\Factory\Psr17\Psr17Factory (extended by SlimPsr17Factory, HttpSoftPsr17Factory, NyholmPsr17Factory, LaminasDiactorosPsr17Factory, GuzzlePsr17Factory, SlimHttpPsr17Factory)
• Consumed By: Slim\Factory\AppFactory, Slim\Factory\ServerRequestCreatorFactory

Defines the static adapter contract used during zero-configuration bootstrap to probe whether a given PSR-7 / PSR-17 library is installed (isResponseFactoryAvailable(), isStreamFactoryAvailable(), isServerRequestCreatorAvailable()) and instantiate its ResponseFactoryInterface, StreamFactoryInterface, or ServerRequestCreatorInterface.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\StreamFactoryInterface;
use RuntimeException;

interface Psr17FactoryInterface
{
    /**
     * @throws RuntimeException when the factory could not be instantiated
     */
    public static function getResponseFactory(): ResponseFactoryInterface;

    /**
     * @throws RuntimeException when the factory could not be instantiated
     */
    public static function getStreamFactory(): StreamFactoryInterface;

    /**
     * @throws RuntimeException when the factory could not be instantiated
     */
    public static function getServerRequestCreator(): ServerRequestCreatorInterface;

    /**
     * Is the PSR-17 ResponseFactory available
     */
    public static function isResponseFactoryAvailable(): bool;

    /**
     * Is the PSR-17 StreamFactory available
     */
    public static function isStreamFactoryAvailable(): bool;

    /**
     * Is the ServerRequest creator available
     */
    public static function isServerRequestCreatorAvailable(): bool;
}

Methods & Parameters#

Usage Example#

use Slim\Factory\Psr17\NyholmPsr17Factory;

if (NyholmPsr17Factory::isResponseFactoryAvailable()) {
    $responseFactory = NyholmPsr17Factory::getResponseFactory();
}

interfaceSlim\Interfaces\Psr17FactoryProviderInterface#

• Source File: Slim/Interfaces/Psr17FactoryProviderInterface.php
• Namespace: Slim\Interfaces
• Default Implementation: Slim\Factory\Psr17\Psr17FactoryProvider
• Consumed By: Slim\Factory\AppFactory, Slim\Factory\ServerRequestCreatorFactory

Defines the registry contract for managing the ordered list of Psr17FactoryInterface class names probed during AppFactory::determineResponseFactory() and ServerRequestCreatorFactory::determineServerRequestCreator().

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

/** @api */
interface Psr17FactoryProviderInterface
{
    /**
     * @return string[]
     */
    public static function getFactories(): array;

    /**
     * @param string[] $factories
     */
    public static function setFactories(array $factories): void;

    public static function addFactory(string $factory): void;
}

Methods & Parameters#

Usage Example#

use Slim\Factory\Psr17\Psr17FactoryProvider;

// Prepend a custom PSR-17 factory adapter to take highest auto-discovery priority:
Psr17FactoryProvider::addFactory(CustomPsr17Factory::class);

interfaceSlim\Interfaces\RequestHandlerInvocationStrategyInterface#

• Source File: Slim/Interfaces/RequestHandlerInvocationStrategyInterface.php
• Namespace: Slim\Interfaces
• Extends: Slim\Interfaces\InvocationStrategyInterface
• Default Implementation: Slim\Handlers\Strategies\RequestHandler

Marker sub-interface extending InvocationStrategyInterface for route invocation strategies that invoke PSR-15 RequestHandlerInterface-style callables (callable(ServerRequestInterface): ResponseInterface) directly.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

interface RequestHandlerInvocationStrategyInterface extends InvocationStrategyInterface
{
}

Methods & Parameters#

Usage Example#

use Slim\Handlers\Strategies\RequestHandler;
use Slim\Interfaces\RequestHandlerInvocationStrategyInterface;

/** @var RequestHandlerInvocationStrategyInterface $strategy */
$strategy = new RequestHandler(true); // pass route arguments as request attributes
$app->getRouteCollector()->setDefaultInvocationStrategy($strategy);

interfaceSlim\Interfaces\RouteCollectorInterface#

• Source File: Slim/Interfaces/RouteCollectorInterface.php
• Namespace: Slim\Interfaces
• Default Implementation: Slim\Routing\RouteCollector
• Consumed By: Slim\App, Slim\Routing\RouteCollectorProxy, Slim\Routing\Dispatcher, Slim\Routing\RouteParser, Slim\Routing\RouteResolver

Defines the central route registry contract responsible for storing RouteInterface and RouteGroupInterface definitions, managing the default InvocationStrategyInterface, configuring FastRoute's compiled PHP cache file, and looking up routes by name or internal identifier (route0, route1, ...).

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use InvalidArgumentException;
use RuntimeException;

/** @api */
interface RouteCollectorInterface
{
    /**
     * Get the route parser
     */
    public function getRouteParser(): RouteParserInterface;

    /**
     * Get default route invocation strategy
     */
    public function getDefaultInvocationStrategy(): InvocationStrategyInterface;

    /**
     * Set default route invocation strategy
     */
    public function setDefaultInvocationStrategy(InvocationStrategyInterface $strategy): RouteCollectorInterface;

    /**
     * Get path to FastRoute cache file
     */
    public function getCacheFile(): ?string;

    /**
     * Set path to FastRoute cache file
     *
     * @throws InvalidArgumentException
     * @throws RuntimeException
     */
    public function setCacheFile(string $cacheFile): RouteCollectorInterface;

    /**
     * Get the base path used in pathFor()
     */
    public function getBasePath(): string;

    /**
     * Set the base path used in pathFor()
     */
    public function setBasePath(string $basePath): RouteCollectorInterface;

    /**
     * Get route objects
     *
     * @return RouteInterface[]
     */
    public function getRoutes(): array;

    /**
     * Get named route object
     *
     * @param string $name Route name
     *
     * @throws RuntimeException   If named route does not exist
     */
    public function getNamedRoute(string $name): RouteInterface;

    /**
     * Remove named route
     *
     * @param string $name Route name
     *
     * @throws RuntimeException   If named route does not exist
     */
    public function removeNamedRoute(string $name): RouteCollectorInterface;

    /**
     * Lookup a route via the route's unique identifier
     *
     * @throws RuntimeException   If route of identifier does not exist
     */
    public function lookupRoute(string $identifier): RouteInterface;

    /**
     * Add route group
     * @param string|callable $callable
     */
    public function group(string $pattern, $callable): RouteGroupInterface;

    /**
     * Add route
     *
     * @param string[] $methods Array of HTTP methods
     * @param string $pattern The route pattern
     * @param callable|array{class-string, string}|string $handler The route callable
     */
    public function map(array $methods, string $pattern, $handler): RouteInterface;
}

Methods & Parameters#

Usage Example#

$collector = $app->getRouteCollector();
$collector->setCacheFile(__DIR__ . '/../var/cache/fastroute.php');

$route = $collector->getNamedRoute('users.show');

interfaceSlim\Interfaces\RouteCollectorProxyInterface#

• Source File: Slim/Interfaces/RouteCollectorProxyInterface.php
• Namespace: Slim\Interfaces
• Template Annotation: @template TContainerInterface of (ContainerInterface|null)
• Default Implementations: Slim\Routing\RouteCollectorProxy, Slim\App

Defines the fluent user-facing routing API shared by both Slim\App and nested route group callbacks ($app->group('/v1', function (RouteCollectorProxyInterface $group) { ... })). Provides convenience methods for all standard HTTP verbs (get(), post(), put(), patch(), delete(), options(), any()), map(), group(), and redirect().

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\UriInterface;

/**
 * @api
 * @template TContainerInterface of (ContainerInterface|null)
 */
interface RouteCollectorProxyInterface
{
    public function getResponseFactory(): ResponseFactoryInterface;

    public function getCallableResolver(): CallableResolverInterface;

    /**
     * @return TContainerInterface
     */
    public function getContainer(): ?ContainerInterface;

    public function getRouteCollector(): RouteCollectorInterface;

    /**
     * Get the RouteCollectorProxy's base path
     */
    public function getBasePath(): string;

    /**
     * Set the RouteCollectorProxy's base path
     * @return RouteCollectorProxyInterface<TContainerInterface>
     */
    public function setBasePath(string $basePath): RouteCollectorProxyInterface;

    /**
     * Add GET route
     *
     * @param string $pattern The route URI pattern
     * @param callable|array{class-string, string}|string $callable The route callback routine
     */
    public function get(string $pattern, $callable): RouteInterface;

    /**
     * Add POST route
     *
     * @param string $pattern The route URI pattern
     * @param callable|array{class-string, string}|string $callable The route callback routine
     */
    public function post(string $pattern, $callable): RouteInterface;

    /**
     * Add PUT route
     *
     * @param string $pattern The route URI pattern
     * @param callable|array{class-string, string}|string $callable The route callback routine
     */
    public function put(string $pattern, $callable): RouteInterface;

    /**
     * Add PATCH route
     *
     * @param string $pattern The route URI pattern
     * @param callable|array{class-string, string}|string $callable The route callback routine
     */
    public function patch(string $pattern, $callable): RouteInterface;

    /**
     * Add DELETE route
     *
     * @param string $pattern The route URI pattern
     * @param callable|array{class-string, string}|string $callable The route callback routine
     */
    public function delete(string $pattern, $callable): RouteInterface;

    /**
     * Add OPTIONS route
     *
     * @param string $pattern The route URI pattern
     * @param callable|array{class-string, string}|string $callable The route callback routine
     */
    public function options(string $pattern, $callable): RouteInterface;

    /**
     * Add route for any HTTP method
     *
     * @param string $pattern The route URI pattern
     * @param callable|array{class-string, string}|string $callable The route callback routine
     */
    public function any(string $pattern, $callable): RouteInterface;

    /**
     * Add route with multiple methods
     *
     * @param string[] $methods Numeric array of HTTP method names
     * @param string $pattern The route URI pattern
     * @param callable|array{class-string, string}|string $callable The route callback routine
     */
    public function map(array $methods, string $pattern, $callable): RouteInterface;

    /**
     * Route Groups
     *
     * This method accepts a route pattern and a callback. All route
     * declarations in the callback will be prepended by the group(s)
     * that it is in.
     * @param string|callable $callable
     */
    public function group(string $pattern, $callable): RouteGroupInterface;

    /**
     * Add a route that sends an HTTP redirect
     *
     * @param string|UriInterface $to
     */
    public function redirect(string $from, $to, int $status = 302): RouteInterface;
}

Methods & Parameters#

Usage Example#

use Slim\Interfaces\RouteCollectorProxyInterface;

$app->group('/api/v1', function (RouteCollectorProxyInterface $group): void {
    $group->get('/users', ListUsersHandler::class)->setName('users.index');
    $group->post('/users', CreateUserHandler::class)->setName('users.create');
    $group->redirect('/legacy', '/api/v1/users', 301);
});

interfaceSlim\Interfaces\RouteGroupInterface#

• Source File: Slim/Interfaces/RouteGroupInterface.php
• Namespace: Slim\Interfaces
• Default Implementation: Slim\Routing\RouteGroup
• Consumed By: Slim\Routing\RouteCollector, Slim\Routing\Route

Defines the contract for a route group returned by RouteCollectorProxyInterface::group(). Allows attaching group-scoped PSR-15 middlewares via add() and addMiddleware(), and appending those middlewares to a matched route's MiddlewareDispatcher when the route executes.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Psr\Http\Server\MiddlewareInterface;
use Slim\MiddlewareDispatcher;

/** @api */
interface RouteGroupInterface
{
    public function collectRoutes(): RouteGroupInterface;

    /**
     * Add middleware to the route group
     *
     * @param MiddlewareInterface|string|callable $middleware
     */
    public function add($middleware): RouteGroupInterface;

    /**
     * Add middleware to the route group
     */
    public function addMiddleware(MiddlewareInterface $middleware): RouteGroupInterface;

    /**
     * Append the group's middleware to the MiddlewareDispatcher
     * @param MiddlewareDispatcher<\Psr\Container\ContainerInterface|null> $dispatcher
     */
    public function appendMiddlewareToDispatcher(MiddlewareDispatcher $dispatcher): RouteGroupInterface;

    /**
     * Get the RouteGroup's pattern
     */
    public function getPattern(): string;
}

Methods & Parameters#

Usage Example#

$app->group('/admin', function ($group): void {
    $group->get('/audit-logs', AuditLogAction::class);
})->add(AdminRoleMiddleware::class);

interfaceSlim\Interfaces\RouteInterface#

• Source File: Slim/Interfaces/RouteInterface.php
• Namespace: Slim\Interfaces
• Default Implementation: Slim\Routing\Route
• Consumed By: Slim\Routing\RouteCollector, Slim\Routing\RouteRunner, Slim\Routing\RouteContext

Defines the contract for an individual route in Slim 4. Each RouteInterface encapsulates its allowed HTTP methods, URI pattern, route callable, route name, unique identifier, matched URI arguments, local InvocationStrategyInterface, and route-level PSR-15 middleware stack executed via run(ServerRequestInterface $request).

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

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

/** @api */
interface RouteInterface
{
    /**
     * Get route invocation strategy
     */
    public function getInvocationStrategy(): InvocationStrategyInterface;

    /**
     * Set route invocation strategy
     */
    public function setInvocationStrategy(InvocationStrategyInterface $invocationStrategy): RouteInterface;

    /**
     * Get route methods
     *
     * @return string[]
     */
    public function getMethods(): array;

    /**
     * Get route pattern
     */
    public function getPattern(): string;

    /**
     * Set route pattern
     */
    public function setPattern(string $pattern): RouteInterface;

    /**
     * Get route callable
     *
     * @return callable|array{class-string, string}|string
     */
    public function getCallable();

    /**
     * Set route callable
     *
     * @param callable|array{class-string, string}|string $callable
     */
    public function setCallable($callable): RouteInterface;

    /**
     * Get route name
     */
    public function getName(): ?string;

    /**
     * Set route name
     *
     * @return static
     */
    public function setName(string $name): RouteInterface;

    /**
     * Get the route's unique identifier
     */
    public function getIdentifier(): string;

    /**
     * Retrieve a specific route argument
     */
    public function getArgument(string $name, ?string $default = null): ?string;

    /**
     * Get route arguments
     *
     * @return array<string, string>
     */
    public function getArguments(): array;

    /**
     * Set a route argument
     *
     * @deprecated 4.14.1 Use a middleware for custom route arguments now.
     */
    public function setArgument(string $name, string $value): RouteInterface;

    /**
     * Replace route arguments
     *
     * @param array<string, string> $arguments
     *
     * @deprecated 4.14.1 Use a middleware for custom route arguments now.
     */
    public function setArguments(array $arguments): self;

    /**
     * @param MiddlewareInterface|string|callable $middleware
     */
    public function add($middleware): self;

    public function addMiddleware(MiddlewareInterface $middleware): self;

    /**
     * Prepare the route for use
     *
     * @param array<string, string> $arguments
     */
    public function prepare(array $arguments): self;

    /**
     * Run route
     *
     * This method traverses the middleware stack, including the route's callable
     * and captures the resultant HTTP response object. It then sends the response
     * back to the Application.
     */
    public function run(ServerRequestInterface $request): ResponseInterface;
}

Methods & Parameters#

Usage Example#

use Slim\Handlers\Strategies\RequestResponseArgs;

$app->get('/orders/{id:[0-9]+}', OrderController::class . ':show')
    ->setName('orders.show')
    ->setInvocationStrategy(new RequestResponseArgs())
    ->add(OrderOwnershipMiddleware::class);

interfaceSlim\Interfaces\RouteParserInterface#

• Source File: Slim/Interfaces/RouteParserInterface.php
• Namespace: Slim\Interfaces
• Default Implementation: Slim\Routing\RouteParser
• Consumed By: Slim\Routing\RouteCollector, Slim\Routing\RouteContext, Slim\Middleware\RoutingMiddleware

Defines the reverse URL generation contract for building relative paths (relativeUrlFor()), base-path-prefixed paths (urlFor()), and fully qualified URLs including scheme and authority (fullUrlFor()) from named routes.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use InvalidArgumentException;
use Psr\Http\Message\UriInterface;
use RuntimeException;

/** @api */
interface RouteParserInterface
{
    /**
     * Build the path for a named route excluding the base path
     *
     * @param string                                           $routeName   Route name
     * @param array<string, string>                            $data        Named argument replacement data
     * @param array<string, string | array<array-key, string>> $queryParams Optional query string parameters
     *
     * @throws RuntimeException         If named route does not exist
     * @throws InvalidArgumentException If required data not provided
     */
    public function relativeUrlFor(string $routeName, array $data = [], array $queryParams = []): string;

    /**
     * Build the path for a named route including the base path
     *
     * @param string                                           $routeName   Route name
     * @param array<string, string>                            $data        Named argument replacement data
     * @param array<string, string | array<array-key, string>> $queryParams Optional query string parameters
     *
     * @throws RuntimeException         If named route does not exist
     * @throws InvalidArgumentException If required data not provided
     */
    public function urlFor(string $routeName, array $data = [], array $queryParams = []): string;

    /**
     * Get fully qualified URL for named route
     *
     * @param UriInterface                                     $uri
     * @param string                                           $routeName   Route name
     * @param array<string, string>                            $data        Named argument replacement data
     * @param array<string, string | array<array-key, string>> $queryParams Optional query string parameters
     */
    public function fullUrlFor(UriInterface $uri, string $routeName, array $data = [], array $queryParams = []): string;
}

Methods & Parameters#

Usage Example#

use Slim\Routing\RouteContext;

$routeParser = RouteContext::fromRequest($request)->getRouteParser();

$relative = $routeParser->relativeUrlFor('orders.show', ['id' => '42']);
$path     = $routeParser->urlFor('orders.show', ['id' => '42'], ['expand' => 'items']);
$fullUrl  = $routeParser->fullUrlFor($request->getUri(), 'orders.show', ['id' => '42']);

interfaceSlim\Interfaces\RouteResolverInterface#

• Source File: Slim/Interfaces/RouteResolverInterface.php
• Namespace: Slim\Interfaces
• Default Implementation: Slim\Routing\RouteResolver
• Consumed By: Slim\App, Slim\Middleware\RoutingMiddleware, Slim\Routing\RouteRunner

Defines the contract bridging RoutingMiddleware with DispatcherInterface and RouteCollectorInterface to compute RoutingResults for an incoming URI and resolve a matched route identifier into its RouteInterface object.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Slim\Routing\RoutingResults;

interface RouteResolverInterface
{
    /**
     * @param string $uri Should be ServerRequestInterface::getUri()->getPath()
     */
    public function computeRoutingResults(string $uri, string $method): RoutingResults;

    public function resolveRoute(string $identifier): RouteInterface;
}

Methods & Parameters#

Usage Example#

$resolver = $app->getRouteResolver();
$results  = $resolver->computeRoutingResults('/users/42', 'GET');
$route    = $resolver->resolveRoute($results->getRouteIdentifier());

interfaceSlim\Interfaces\ServerRequestCreatorInterface#

• Source File: Slim/Interfaces/ServerRequestCreatorInterface.php
• Namespace: Slim\Interfaces
• Default Implementations: Slim\Factory\Psr17\ServerRequestCreator, Slim\Factory\Psr17\SlimHttpServerRequestCreator
• Consumed By: Slim\App::run(), Slim\Factory\ServerRequestCreatorFactory

Defines the contract for synthesizing a PSR-7 ServerRequestInterface from PHP SAPI superglobals ($_SERVER, $_GET, $_POST, $_COOKIE, $_FILES) when App::run() is called without an explicit request argument.

PHP Interface Signature#

<?php

declare(strict_types=1);

namespace Slim\Interfaces;

use Psr\Http\Message\ServerRequestInterface;

interface ServerRequestCreatorInterface
{
    public function createServerRequestFromGlobals(): ServerRequestInterface;
}

Methods & Parameters#

Usage Example#

use Slim\Factory\ServerRequestCreatorFactory;

$creator = ServerRequestCreatorFactory::create();
$request = $creator->createServerRequestFromGlobals();
$app->run($request);