Why can't I run IOC Scopes on a global middleware?

[sicet7]

Hello 👋

I have been chasing a exception for the past 5 hours now and I think i am lost 😅
The exception message i get is this:

Can't resolve `middleware:api`: undefined class or binding `middleware:api`.
Container trace list:
- action: 'autowire'
  alias: 'middleware:api'
  context: null

And i get it when i try to add my TestMiddleware class to the global middlewares.
My TestMiddleware (Based on code from the documentation)

namespace App\Endpoint\Http\Middleware;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Spiral\Core\Attribute\Scope;
use Spiral\Core\ScopeInterface;

final readonly class UserContext
{
    /**
     * @param int $testNumber
     * @param string $testString
     */
    public function __construct(
        public int    $testNumber,
        public string $testString,
    ) {
    }
}

#[Scope('http')]
final class TestMiddleware implements MiddlewareInterface
{
    public function __construct(private readonly ScopeInterface $scope)
    {
    }

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        return $this->scope->runScope([
            UserContext::class => new UserContext(123, 'test')
        ], function () use ($handler, $request) {
            return $handler->handle($request);
        });
    }
}

This is a snippet from my Routes bootloader:

// More code...

/**
     * @inheritDoc
     */
    protected function globalMiddleware(): array
    {
        $middlewares = [
            ErrorHandlerMiddleware::class,
            TokenExpiredMiddleware::class,
            (class_exists(DumperMiddleware::class) ? DumperMiddleware::class : null),
            (class_exists(DumperMiddleware::class) ? ExposeDumpMiddleware::class : null),
            new Autowire(AuthTransportWithStorageMiddleware::class, [
                'transportName' => 'header',
                'storage' => 'custom_jwt',
            ]),
            TestMiddleware::class, // <-- This breaks everything
//            AuthMapperMiddleware::class,
            OnlyJsonMiddleware::class,
            JsonPayloadMiddleware::class,
            HttpCollector::class,
        ];

        //Remove unwanted values from middleware array without affecting order.
        /** @var array<MiddlewareInterface|class-string<MiddlewareInterface>> $output */
        $output = array_filter($middlewares, fn ($v) => \is_string($v) || $v instanceof Autowire);
        return $output;
    }

    /**
     * @inheritDoc
     */
    protected function middlewareGroups(): array
    {
        return [
            'api' => [
                //TestMiddleware::class, <-- This works fine
                ValidationHandlerMiddleware::class,
            ],
        ];
    }
// More code...

So i guess my questions are:

1. How can I run IOC Scopes from a global middleware?
2. Why does global middlewares and middleware groups not work the same?
3. If this is intended should it not be documented? (if it is I missed it 😅)

P.S: I posted the question here due to the size limit on Discord messages.

[roxblnfk]

Hi

There is a new documentation about scopes in review: spiral/docs#710
Note that you are starting the Scope in an outdated way. You need to pass the Scope DTO as the first argument.

Why does global middlewares and middleware groups not work the same?

I need to verify this assumption. In Spiral v3.15, LazyPipeline was added, which should ensure the correct functioning of Scopes in middleware.

[sicet7]

Hi,

Thank for your reply 🙂

Im aware that bind via. the array is deprecated, but since the Spiral\Core\Scope class is marked as internal, using the array way is the only way I can make bindings without getting PSALM errors 🙂

Also to make sure it was not just me being crazy, I wanted to test something from the documentation.

I am not sure what the LazyPipeline does, but i also only traced the global middlewares to the configuration and left it there.

In my tests i am running spiral/framework 3.15.0, I will update to 3.15.2 to see if that does anything, but reading the release notes, it does not seem to have touched that part of the code 🙂

[sicet7]

I have been looking into where the global middlewares are resolved and it seems to me that the global middleware or just the middlewares from the configration is resolved from the container here: https://github.com/spiral/framework/blob/master/src/Http/src/Http.php#L40
which is resolved in the HttpBootloader here: https://github.com/spiral/framework/blob/master/src/Framework/Bootloader/Http/HttpBootloader.php#L144

I am no expert but here is my theory, if the httpCore method is called to resolve the Http object before the scope is in the "correct" state then maybe that is why the middlewares which has the ScopeInterface in their contructor have issues being resolved with the expected parent scope.

[sicet7]

Ahhh nvm, I jumped the gun there 🤦‍♂️

That is only if it is not a LazyPipeline that is provided and as you mentioned the LazyPipeline should(looking at the code) only resolve the middleware when the request is being handled.

I apologise for wasting your time with the previous message, I will dig deeper 😅

[roxblnfk]

the Spiral\Core\Scope class is marked as internal

It's time to make it public in 3.15.3