Weave Code
Code Weaver
Helps Laravel developers discover, compare, and choose open-source packages. See popularity, security, maintainers, and scores at a glance to make better decisions.
Feedback
Share your thoughts, report bugs, or suggest improvements.
Subject
Message
Log in Register
Home
Packages
Framework
Release Notes

Framework Laravel Package

spiral/framework

Spiral Framework is a high-performance, long-running full-stack PHP framework with 60+ PSR-compatible components. Powered by RoadRunner for resident-memory apps, it supports GRPC, queues, WebSockets, background workers, and more.

View on GitHub
Deep Wiki
Context7
3.16.1

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.16.0...3.16.1

3.16.0

Highlights

PHP Attributes for Bootloader Methods

The most significant addition in this release is comprehensive support for PHP attributes in bootloaders, providing a modern, type-safe approach to application bootstrapping. You can now use attributes like #[SingletonMethod], #[BindMethod], #[BindScope], and priority-based lifecycle methods for cleaner and more expressive bootloader configuration.

Container Optimization

Major performance improvements to the container's dependency resolution with iterative scope resolution, eliminating recursive overhead and reducing exception handling for faster dependency injection.

Modern PHP Tooling

Full support for PHP 8.4, Psalm v6, Symfony Console 8, and migration to PHPUnit attributes for a modern development experience.

Features

PHP Attributes for Bootloader Methods

This major feature adds PHP attributes for configuring bootloaders, providing a more expressive and type-safe approach to application bootstrapping.

Available Attributes:

  • #[BindMethod] - Container bindings that create new instances
  • #[SingletonMethod] - Container bindings that create shared instances
  • #[InjectorMethod] - Custom injector methods
  • #[BindAlias] - Multiple aliases for bindings
  • #[BindScope] - Scoped bindings
  • #[InitMethod] - Initialization phase methods with priority control
  • #[BootMethod] - Boot phase methods with priority control

Example:

class DatabaseBootloader extends Bootloader
{
    #[SingletonMethod]
    #[BindScope('http')]
    public function createConnection(): ConnectionInterface
    {
        return new Connection(...);
    }
    
    #[InitMethod(priority: 100)]
    public function registerCoreServices(Container $container): void
    {
        // Register core services first
    }
}

Benefits:

  • Type-safety leveraging PHP's type system
  • Clearer intent with attributes vs. method names
  • Fine-grained control over execution order
  • Modern PHP 8+ attribute syntax

PR #1190 | Author: [@butschster](https://github.com/butschster)

HTTP LINK and UNLINK Methods Support

Extends HTTP method support to include LINK and UNLINK verbs as specified in RFC 2068 and RFC 5988, allowing applications to handle specialized HTTP verbs for managing relationships between resources.

PR #1230 | Author: [@gam6itko](https://github.com/gam6itko)

Mailer: Reply-To Header Support

Adds support for the Reply-To email header in the SendIt mailer component. Email messages can now properly set and handle Reply-To headers, allowing recipients to reply to a different address than the sender.

PR #1232 | Author: [@burn1ngbear](https://github.com/burn1ngbear)

Mailer: Pre and Post Render Events

Adds event hooks to the email rendering process for better extensibility:

  • Pre-render event: Triggered before email template rendering
  • Post-render event: Triggered after email template rendering

This allows modification of email content before rendering and enables logging, validation, or transformation after rendering.

PR #1233 | Author: [@burn1ngbear](https://github.com/burn1ngbear)

Reactor: Constant Type Management

Adds missing methods to the Reactor component for working with constant types, improving the code generation capabilities when managing constant type information in generated PHP code.

PR #1220 | Author: [@butschster](https://github.com/butschster)

Performance

Container Optimization

Major performance optimization for the container's dependency resolution and scope handling:**

  • Fixed Invoker::invoke() to avoid unnecessary class instantiation when calling static functions
  • Added internal Container Actor service for improved service management
  • Refactored Tracer to create new instances for each separated Container operation
  • Improved resolving traces in container exceptions for better debugging
  • Optimized scope resolution to use iterative loop instead of recursive Factory::make() calls

The iterative scope resolution eliminates recursive overhead and reduces exception handling, resulting in significantly faster dependency resolution.

PR #1221 | Author: [@roxblnfk](https://github.com/roxblnfk)

Queue: Optimize Telemetry Span Names

Optimizes telemetry trace naming for queue job processing by removing job IDs from span names. This reduces cardinality and allows proper grouping of traces by job type in observability tools, resulting in better trace aggregation, easier performance pattern identification, and reduced storage overhead.

PR #1215 | Author: [@rauanmayemir](https://github.com/rauanmayemir)

🐛 Bug Fixes

Router: Fix Group Prefix Application

Fixes a bug where route group prefixes were not being automatically applied to routes in the group. Previously, developers had to manually include the prefix in each route path or add it explicitly, which was counter-intuitive. Now group prefixes are automatically applied to all routes in the group as expected.

PR #1219 | Author: [@butschster](https://github.com/butschster) | Closes: #1217

Telemetry: Fix Trace Context Propagation

Critical bug fix for the telemetry component that was preventing trace context from being added to log records. The tracer was not using the scoped proxy container, resulting in empty trace context. Fixed by ensuring TelemetryProcessor uses the scoped container properly.

PR #1212 | Author: [@rauanmayemir](https://github.com/rauanmayemir)

Telemetry: Bind TracerInterface as Singleton

Fixes an issue where TracerInterface was overwriting trace context every time it was accessed, causing traces to be lost frequently. The solution binds current TracerInterface as singleton for consistent trace context within request scope and fixes scope handling in AbstractTracer::runScope method.

Benefits:

  • Reliable access to trace context during request scope
  • Improved integration with Monolog telemetry processor
  • Prevents trace context loss during request processing

PR #1214 | Author: [@rauanmayemir](https://github.com/rauanmayemir)

Core: Fix static Return Type in Proxy Generator

Fixes a critical bug in the proxy class generator that caused failures when proxying interfaces with static return types. The generator now properly handles static return type, preventing failures in dependency injection and scoped bindings. Also adds resolving trace to resolver exceptions for better debugging.

PR #1222 | Author: [@roxblnfk](https://github.com/roxblnfk)

Console: Fix Symfony Console 7.4+ Deprecation

Fixes deprecation warnings when using Symfony Console 7.4+ and adds support for Symfony 8. Replaced deprecated add() method with addCommand() for Symfony 7.4+ while maintaining backward compatibility with Symfony 6.4. Updated version constraints to ^6.4.17 || ^7.2 || ^8.0.

PR #1240 | Author: [@gam6itko](https://github.com/gam6itko)

Queue: Fix Return Type Annotation

Corrects the return type annotation for the getDelay() method to match actual behavior and improve static analysis accuracy.

PR #1238 | Author: [@roxblnfk](https://github.com/roxblnfk)

🔧 Improvements

PHP 8.4 and Psalm v6 Support

  • Upgraded to Psalm v6 for static analysis
  • Updated Prototype component to use nikic/php-parser v5
  • Added PHP 8.4 to CI pipeline
  • Fixed Psalm and Rector issues

PR #1205 | Author: [@msmakouz](https://github.com/msmakouz)

General Maintenance

General maintenance update including dependency updates, code cleanup, and minor improvements across the framework.

PR #1236 | Author: [@roxblnfk](https://github.com/roxblnfk)

📦 Full Changelog

Full Changelog: https://github.com/spiral/framework/compare/3.15.0...3.16.0

🙏 Thanks

A huge thank you to all contributors who made this release possible:

3.15.8

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.15.7...3.15.8

3.15.7

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.15.6...3.15.7

3.15.6

What's Changed

  • Optimize container and fix invoker by @roxblnfk in https://github.com/spiral/framework/pull/1221
    • Invoker::invoke() does not try to instantiate class to call a static function
    • Added an internal Container Actor service
    • Remove Tracer from services. Now a new one might be created for a separated Container operation
    • Reworked resolving traces in container exceptions

Full Changelog: https://github.com/spiral/framework/compare/3.15.5...3.15.6

3.15.5

What's Changed

Bug Fixes

Full Changelog: https://github.com/spiral/framework/compare/3.15.0...3.15.6

3.15.4

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.15.3...3.15.4

3.15.3

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.15.2...3.15.3

3.15.2

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.15.0...3.15.2

3.15.1

What's changed

  • Maintenance by @roxblnfk and @msmakouz in #1205
    • Psalm v6
    • The Prototype component now uses nikic/php-parser v5
    • Bumped up dependencies versions
    • Added PHP 8.4 in the CI

Full Changelog: https://github.com/spiral/framework/compare/3.15.0...3.15.1

3.15.0

What's Changed

Core

  • AppEnvironment enum: added aliases for production and test environments (#1170).
  • Added a new option in the container to control default behavior when rebinding singletons (#1199).
    In the future, the container will be stricter by default, so it's recommended to set allowSingletonsRebinding to false right away.
  • Fixed resolving of scoped Autowire objects (#1175).

Cache

  • Added events that are dispatched before cache operations like KeyWriting, CacheRetrieving, KeyDeleting and failed operations like KeyWriteFailed, KeyDeleteFailed (#1156).
  • Optimized operations with multiple cache records (#1194).
  • Added an ability to set custom cache storage (#1142).

Router

  • The ServerRequestInterface object is now passed into the call context of interceptors (#1168)
  • Added a new middleware pipeline LazyPipeline (#1168)
    The pipeline resolves middleware from the container right before execution to avoid ignoring container scopes. \Spiral\Http\Pipeline is deprecated now.
  • Added strict mode for UriHandler (#1192)
    Strict mode ensures all required URI segments are validated. If any are missing, an exception is thrown. 
    $handler = $container->get(\Spiral\Router\UriHandler::class);
$handler->setStrict(true);

Telemetry

Optimized the telemetry component (#1168): it no longer opens a container scope each time in the AbstractTracer::runScope() method.

spiral/otel-bridge v1.2.2 has been released, which includes normalization of values for OTEL data types.

Changes in telemetry operation in the router:

  • A new Span is no longer created for each Middleware: the pipeline fills the list with called middlewares in one span. The number of pipelines equals the number of spans.
  • The http.response_content_length field is no longer filled.

Code quality improvements:

We are preparing to start the 4.x branch. This means it's time to "tidy up" the codebase: update all the code so that the difference between 3.x and 4.x is minimal. This way, fixes from 4.x can be easily applied to 3.x.

Pull requests using Rector from @samsonasik are very timely here:

  • Bump to Rector ~2.0.0 in #1155, #1159, #1177
  • Update to use PHPUnit 10 syntax in #1163
  • Fix @template-covariant usage on Target and TargetInterface in #1164
  • Add closure void return type in tests in #1180, #1181
  • Add typed MockObject in tests in #1182
  • Add ArrowFunction and Closure return type in #1183, #1184, #1201
  • Add property types on tests classes in #1185
  • Enable phpunit code quality set for rector in #1186
  • Run Rector on submodule under src/Bridge as well in #1189
  • Add typed on private property based on assigns in #1200
  • Set setUp()/tearDown() method modifier protected on tests in #1202

And Code Style improvements:

  • Apply Spiral code style in #1207, #1208

Pull requests

  • Merge hotfixes from 3.14.x by @roxblnfk in #1167
  • CacheManager ability to set custom cache storage. by @gam6itko in #1142
  • AppEnvironment: add aliases for production and test environments by @roxblnfk in #1170
  • Telemetry and middleware improvements by @roxblnfk in #1168
  • [Core] Fix scoped Autowire resolving by @roxblnfk in #1175
  • feat(Cache): pre-operation events by @leon0399 in #1156
  • Provide an ability to set strict container singletons via options by @butschster in #1199
  • Add strict mode for UriHandler by @butschster in #1192
  • Using proper method for multiple cache records. by @butschster in #1194
  • Apply Spiral code style by @roxblnfk in #1207, #1208
  • Bump to Rector ~2.0.0 by @samsonasik in #1155, #1159, #1177
  • Update to use PHPUnit 10 syntax by @samsonasik in #1163
  • Fix @template-covariant usage on Target and TargetInterface by @samsonasik in #1164
  • refactor: add closure void return type in tests by @samsonasik in #1180, #1181
  • refactor: add typed MockObject in tests by @samsonasik in #1182
  • refactor: Add ArrowFunction return type by @samsonasik in #1183
  • refactor: add Closure return type by @samsonasik in #1184
  • refactor: add property types on tests classes by @samsonasik in #1185
  • refactor: enable phpunit code quality set for rector by @samsonasik in #1186
  • refactor: Run Rector on submodule under src/Bridge as well by @samsonasik in #1189
  • refactor: add typed on private property based on assigns by @samsonasik in #1200
  • refactor: add never return type on closure by @samsonasik in #1201
  • refactor: set setUp()/tearDown() method modifier protected on tests by @samsonasik in #1202

Full Changelog: https://github.com/spiral/framework/compare/3.14.6...v3.15.0

3.14.10

What was changed

Bug Fixes

  • [spiral/telemetry] Improve types for SpanInterface (#1206)
  • [spiral/stempler] Fix parsing of @ inside a string that is not a directive (#1197)

Full Changelog: https://github.com/spiral/framework/compare/3.14.9...3.14.10

3.14.9

What's Changed

  • [spiral/core] Auth* middlewares are defined in http scope (#1176)
  • [spiral/auth-http] Fixed injectors binding via Binder::bind method (#1195)
  • [spiral/telemetry] Fixed returning type in TelemetryProcessor for Monolog (#1193)
  • [spiral/stempler] Fixed directory import (#1191)

Full Changelog: https://github.com/spiral/framework/compare/3.14.8...3.14.9

3.14.8

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.14.7...3.14.8

3.14.7

What's Changed

New Contributors

Full Changelog: https://github.com/spiral/framework/compare/3.14.6...3.14.7

3.14.6

What's Changed

New Contributors

Full Changelog: https://github.com/spiral/framework/compare/3.14.5...3.14.6

3.14.5

What's Changed

New Contributors

Full Changelog: https://github.com/spiral/framework/compare/3.14.4...3.14.5

3.14.4

What's Changed

  • Container scope related fixes by @roxblnfk in https://github.com/spiral/framework/pull/1149:
    • [spiral/router] Router now uses proxied container to create middlewares in a right scope.
    • [spiral/router] Better binding for the interceptor handler.
    • DebugBootloader now uses a Factory Proxy to resolve collectors. Unresolved collectors don't break state populating flow.

Full Changelog: https://github.com/spiral/framework/compare/3.14.3...3.14.4

3.14.3

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.14.2...3.14.3

3.14.2

What's Changed

Fixes:

Code quality:

New Contributors

Full Changelog: https://github.com/spiral/framework/compare/3.14.1...3.14.2

3.14.1

What's Changed

Fixes

Code quality

3.14.0

[!WARNING] If you are using spiral/roadrunner-bridge, you need to update it to version ^3.7 or ^4.0.

New Interceptors

The HMVC package has been deprecated. It has been replaced by the new spiral/interceptors package, where we have reworked the interceptors. The basic principle remains the same, but the interface is now more understandable and convenient.

InterceptorInterface

In the old CoreInterceptorInterface, the $controller and $action parameters caused confusion by creating a false association with HTTP controllers. However, interceptors are not tied to HTTP and are used universally. Now, instead of $controller and $action, we use the Target definition, which can point to more than just class methods.

The $parameters parameter, which is a list of arguments, has now been moved to the CallContextInterface invocation context.

/** [@deprecated](https://github.com/deprecated) Use InterceptorInterface instead */
interface CoreInterceptorInterface
{
    public function process(string $controller, string $action, array $parameters, CoreInterface $core): mixed;
}

interface InterceptorInterface
{
    public function intercept(CallContextInterface $context, HandlerInterface $handler): mixed;
}

CallContextInterface

The CallContextInterface invocation context contains all the information about the call:

  • Target — the definition of the call target.
  • Arguments — the list of arguments for the call.
  • Attributes — additional context that can be used to pass data between interceptors.

[!NOTE] CallContextInterface is immutable.

TargetInterface

TargetInterface defines the target whose call we want to intercept.

If you need to replace the Target in the interceptor chain, use the static methods of the \Spiral\Interceptors\Context\Target class to create a new Target.

The basic set includes several types of Target:

  • Target::fromReflectionMethod(ReflectionFunctionAbstract $reflection, class-string|object $classOrObject)
    Creates a Target from a method reflection. The second argument is mandatory because the method reflection may refer to a parent class.
  • Target::fromReflectionFunction(\ReflectionFunction $reflection, array $path = [])
    Creates a Target from a function reflection.
  • Target::fromClosure(\Closure $closure, array $path = [])
    Creates a Target from a closure. Use PHP 8 syntax for better clarity: 
    $target = Target::fromClosure($this->someAction(...));
  • Target::fromPathString(string $path, string $delimiter = '.') and Target::fromPathArray(array $path, string $delimiter = '.')
    Creates a Target from a path string or array. In the first case, the path is split by the delimiter; in the second, the delimiter is used when converting the Target to a string. This type of Target without an explicit handler is used for RPC endpoints or message queue dispatching.
  • Target::fromPair(string|object $controller, string $action)
    An alternative way to create a Target from a controller and method, as in the old interface. The method will automatically determine how the Target should be created.

Compatibility

Spiral 3.x will work as expected with both old and new interceptors. However, new interceptors should be created based on the new interface.

In Spiral 4.x, support for old interceptors will be disabled. You will likely be able to restore it by including the spiral/hmvc package.

Building an Interceptor Chain

If you need to manually build an interceptor chain, use \Spiral\Interceptors\PipelineBuilderInterface.

In Spiral v3, two implementations are provided:

  • \Spiral\Interceptors\PipelineBuilder — an implementation for new interceptors only.
  • \Spiral\Core\CompatiblePipelineBuilder — an implementation from the spiral/hmvc package that supports both old and new interceptors simultaneously.

[!NOTE] In Spiral 3.14, the implementation for PipelineBuilderInterface is not defined in the container by default. CompatiblePipelineBuilder is used in Spiral v3 services as a fallback implementation. If you define your own implementation, it will be used instead of the fallback implementation in all framework pipelines.

At the end of the interceptor chain, there should always be a \Spiral\Interceptors\HandlerInterface, which will be called if the interceptor chain does not terminate with a result or exception.

The spiral/interceptors package provides several basic handlers:

  • \Spiral\Interceptors\Handler\CallableHandler — simply calls the callable from the Target "as is".
  • \Spiral\Interceptors\Handler\AutowireHandler — calls a method or function, resolving missing arguments using the container.
use Spiral\Core\CompatiblePipelineBuilder;
use Spiral\Interceptors\Context\CallContext;
use Spiral\Interceptors\Context\Target;
use Spiral\Interceptors\Handler\CallableHandler;

$interceptors = [
    new MyInterceptor(),
    new MySecondInterceptor(),
    new MyThirdInterceptor(),
];

$pipeline = (new CompatiblePipelineBuilder())
    ->withInterceptors(...$interceptors)
    ->build(handler: new CallableHandler());

$pipeline->handle(new CallContext(
    target: Target::fromPair($controller, $action),
    arguments: $arguments,
    attributes: $attributes,
));

Pull Requests

Container Scopes

Container Scopes are integrated even deeper. In Spiral, each type of worker is handled by a separate dispatcher. Each dispatcher has its own scope, which can be used to limit the set of services available to the worker.

During request processing, such as HTTP, the context (ServerRequestInterface) passes through a middleware pipeline. At the very end, when the middleware has finished processing and the controller has not yet been called, there is a moment when the request context is finally prepared. At this moment, the contextual container scope (in our case, http-request) is opened, and the ServerRequestInterface is placed in the container. In this scope, interceptors come into play, after which the controller is executed.

As before, you can additionally open scopes in middleware, interceptors, or the business layer, for example, to limit the authorization context in a multi-tenant application.

You can view the names of dispatcher scopes and their contexts in the enum \Spiral\Framework\Spiral.

Pull Requests

  • [spiral/router] Opening of http.request scope added by @msmakouz in #1069
  • Change the name of the enum from ScopeName to Spiral by @msmakouz in #1078
  • Added PaginationProviderInterface binding in scope by @msmakouz in #1079
  • Console scopes by @butschster in #1085
  • [spiral/queue] Add Proxy to the InvokerInterface in JobHandler by @msmakouz in #1091
  • Usage of scopes in sessions and auth, adding CurrentRequest by @msmakouz in #1080
  • Merge changes from the master branch by @msmakouz in #1103
  • Integrate Container Scopes by @roxblnfk in #1104
  • Rename context scopes by @roxblnfk in #1127

Fixes

  • Fix psalm issue: remove internal annotation from LoggerTrait::$logger by @gam6itko in #1118
  • Fix psalm issues related to TracerFactoryInterface by @gam6itko in #1119
  • Fix error when a file from the stacktrace doesn't exist by @roxblnfk in #1114
  • Fix an exception message by @msmakouz in #1115
  • Fix OTEL: cast request URI to string for http.url trace attribute by @devnev in #1126
  • Fix psalm issues about Spiral\Queue\HandlerInterface::handle() by @gam6itko in #1120
  • Fix funding links by @roxblnfk in #1123

New Contributors

  • @devnev made their first contribution in #1126

Full Changelog: https://github.com/spiral/framework/compare/3.13.0...3.14.1

3.13.0

New features

1. Introduced LoggerChannel attribute

We are excited to introduce a new feature that enhances the flexibility of the logging component. With the new LoggerChannel attribute, developers can now specify the logger channel directly in the code.

Example Usage:

class SomeService
{
	public function __construct(
	    // Logger with channel `roadrunner` will be injected
		#[LoggerChannel('roadrunner')] public LoggerInterface $logger
	){}
}

This feature allows for better organization and clarity in logging, helping you maintain and debug your application more efficiently.

by @roxblnfk in https://github.com/spiral/framework/pull/1102

2. Added an ability additionally to scan parent classes.

With this update, you can now scan for attributes in parent classes, making your class discovery process more comprehensive and efficient.

Why This Matters

Previously, the tokenizer could only listen to classes where attributes were found. This limitation did not allow for the automatic (convenient) detection of classes by parent attributes and the effective use of the tokenizer cache. With this update, it will also listen to interfaces that the class with the attribute implements and the classes that it extends. This new feature leverages the full power of the tokenizer without the need to scan all classes and handle them manually, ensuring a more efficient and thorough attribute detection process.

Here is a practical example of how to use this feature:

use Spiral\Tokenizer\Attribute\TargetAttribute;

#[TargetAttribute(attribute: MyAttribute::class, scanParents: true)]
class MyListener implements TokenizationListenerInterface
{
    public function listen(\ReflectionClass $class): void
    {
        // Your logic here
    }

    public function finalize(): void
    {
        // Your logic here
    }
}

by @roxblnfk in https://github.com/spiral/framework/pull/1110

Other

Full Changelog: https://github.com/spiral/framework/compare/3.12.0...3.13.0

3.12.0

New features

1. Improved container injectors

spiral/core Advanced Context Handling in Injector Implementations by @roxblnfk in https://github.com/spiral/framework/pull/1041

This pull request presents a significant update to the injector system, focusing on the createInjection method of the Spiral\Core\Container\InjectorInterface. The key enhancement lies in the augmented ability of the injector to handle context more effectively.

Previously, the createInjection method accepted two parameters: the ReflectionClass object of the requested class and a context, which was limited to being either a string or null. This approach, while functional, offered limited flexibility in dynamically resolving dependencies based on the calling context.

The updated createInjection method can now accept an extended range of context types including Stringable|string|null, mixed, or ReflectionParameter|string|null. This broadening allows the injector to receive more detailed contextual information, enhancing its capability to make more informed decisions about which implementation to provide.

Now you can do something like this:

<?php

declare(strict_types=1);

namespace App\Application;

final class SomeService
{
    public function __construct(
        #[DatabaseDriver(name: 'mysql')]
        public DatabaseInterface $database,

        #[DatabaseDriver(name: 'sqlite')]
        public DatabaseInterface $database1,
    ) {
    }
}

And example of injector

<?php

declare(strict_types=1);

namespace App\Application;

use Spiral\Core\Container\InjectorInterface;

final class DatabaseInjector implements InjectorInterface
{
    public function createInjection(\ReflectionClass $class, \ReflectionParameter|null|string $context = null): object
    {
        $driver = $context?->getAttributes(DatabaseDriver::class)[0]?->newInstance()?->name ?? 'mysql';

        return match ($driver) {
            'sqlite' => new Sqlite(),
            'mysql' => new Mysql(),
            default => throw new \InvalidArgumentException('Invalid database driver'),
        };
    }
}

2. Added ability to suppress non-reportable exceptions

Add non-reportable exceptions by @msmakouz in https://github.com/spiral/framework/pull/1044

The ability to exclude reporting of certain exceptions has been added. By default, Spiral\Http\Exception\ClientException, Spiral\Filters\Exception\ValidationException, and Spiral\Filters\Exception\AuthorizationException are ignored.

Exceptions can be excluded from the report in several different ways:

Attribute NonReportable

To exclude an exception from the report, you need to add the Spiral\Exceptions\Attribute\NonReportable attribute to the exception class.

use Spiral\Exceptions\Attribute\NonReportable;

#[NonReportable]
class AccessDeniedException extends \Exception
{
    // ...
}

Method dontReport

Invoke the dontReport method in the Spiral\Exceptions\ExceptionHandler class. This can be done using the bootloader.

use Spiral\Boot\Bootloader\Bootloader;
use Spiral\Exceptions\ExceptionHandler;

final class AppBootloader extends Bootloader
{
    public function init(ExceptionHandler $handler): void
    {
        $handler->dontReport(EntityNotFoundException::class);
    }
}

Overriding the property nonReportableExceptions

You can override the nonReportableExceptions property with predefined exceptions.

3. Better container scopes

This release marks a foundational shift in how we approach dependency management within our framework, setting the stage for the upcoming version 4.0. With these changes, we're not just tweaking the system; we're laying down the groundwork for more robust, efficient, and intuitive handling of dependencies in the long run. To ensure everyone can make the most out of these updates, we will be rolling out a series of tutorials aimed at helping you navigate through the new features and enhancements.

Context

The context is also extended on other container methods get() (see https://github.com/spiral/framework/pull/1041)

Scopes

Default scope fix

If the container scope is not open, it is assumed by default that dependencies are resolved in the scope named root. Now when calling invoke(), make(), get(), the container will globally register itself with the root scope if no other scope was opened. Before this, the container resolved dependencies as if outside the scope.

Scoped Interface

The experimental ContainerScopeInterface has been removed. The method getBinder(?string $scope = null): BinderInterface has been moved to BinderInterface at the annotation level.

runScope method

The Container::runScoped() method (in the implementation) was additionally marked as [@deprecated](https://github.com/deprecated) and will be removed when its use in tests is reduced to zero. Instead of the Container::runScoped(), you should now call the old Container::runScope(), but with passing the DTO Spiral\Core\Scope instead of the list of bindings.

$container->runScope(
    new Scope(name: 'auth', bindings: ['actor' => new Actor()]),
    function(ContainerInterface $container) {
        dump($container->get('actor'));
    },
);

Scope Proxy

Instead of the now removed ContainerScopeInterface::getCurrentContainer() method, the user is offered another way to get dependencies from the container of the current scope - a proxy.

The user can mark the dependency with a new attribute Spiral\Core\Attribute\Proxy.

Warning: The dependency must be defined by an interface.

When resolving dependencies, the container will create a proxy object that implements the specified interface. When calling the interface method, the proxy object will get the container of the current scope, request the dependency from it using its interface, and start the necessary method.

final class Service  
{
    public function __construct(  
        #[Proxy] public LoggerInterface $logger,  
    ) {  
    }

    public function doAction() {
        // Equals to
        // $container->getCurrentContainer()->get(LoggerInterface::class)->log('foo')
        $this->logger->log('foo'); 
    }
}

Important nuances:

  • The proxy refers to the active scope of the container, regardless of the scope in which the proxy object was created.
  • Each call to the proxy method pulls the container. If there are many calls within the method, you should consider making a proxy for the container 
    // class
function __construct(
    #[Proxy] private Dependency $dep,
    #[Proxy] private ContainerInterface $container,
) {}
function handle() {
    // There are four calls to the container under the hood.
    $this->dep->foo();
    $this->dep->bar();
    $this->dep->baz();
    $this->dep->red();

    // Only two calls to the container and caching the value in a variable
    // The first call - getting the container through the proxy
    // The second - explicit retrieval of the dependency from the container
    $dep = $this->container->get(Dependency::class);
    $dep->foo();
    $dep->bar();
    $dep->baz();
    $dep->red();
}
  • The proxied interface should not contain a constructor signature (although this sometimes happens).
  • Calls to methods outside the interface will not be proxied. This option is possible in principle, but it is disabled. If it is absolutely necessary, we will consider whether to enable it.
  • The destructor method call will not be proxied.

Proxy

Added the ability to bind an interface as a proxy using the Spiral\Core\Config\Proxy configuration. This is useful in cases where a service needs to be used within a specific scope but must be accessible within the container for other services in root or other scopes (so that a service requiring the dependency can be successfully created and used when needed in the correct scope).

use Spiral\Boot\Bootloader\Bootloader;
use Spiral\Core\BinderInterface;
use Spiral\Core\Config\Proxy;
use Spiral\Framework\ScopeName;
use Spiral\Http\PaginationFactory;
use Spiral\Pagination\PaginationProviderInterface;

final class PaginationBootloader extends Bootloader
{
    public function __construct(
        private readonly BinderInterface $binder,
    ) {
    }
    
    public function defineSingletons(): array
    {
        $this->binder
            ->getBinder(ScopeName::Http)
            ->bindSingleton(PaginationProviderInterface::class, PaginationFactory::class);
        
        $this->binder->bind(
            PaginationProviderInterface::class,
            new Proxy(PaginationProviderInterface::class, true)  // <-------
        );

        return [];
    }
}

DeprecationProxy

Similar to Proxy, but also allows outputting a deprecation message when attempting to retrieve a dependency from the container. In the example below, we use two bindings, one in scope and one out of scope with Spiral\Core\Config\DeprecationProxy. When requesting the interface in scope, we will receive the service, and when requesting it out of scope, we will receive the service and a deprecation message.

use Spiral\Boot\Bootloader\Bootloader;
use Spiral\Core\BinderInterface;
use Spiral\Core\Config\DeprecationProxy;
use Spiral\Framework\ScopeName;
use Spiral\Http\PaginationFactory;
use Spiral\Pagination\PaginationProviderInterface;

final class PaginationBootloader extends Bootloader
{
    public function __construct(
        private readonly BinderInterface $binder,
    ) {
    }

    public function defineSingletons(): array
    {
        $this->binder
            ->getBinder(ScopeName::Http)
            ->bindSingleton(PaginationProviderInterface::class, PaginationFactory::class);

        $this->binder->bind(
            PaginationProviderInterface::class,
            new DeprecationProxy(PaginationProviderInterface::class, true, ScopeName::Http, '4.0') // <----------
        );

        return [];
    }
}

DispatcherScope

Added the ability to specify the scope name for the dispatcher using the Spiral\Attribute\DispatcherScope attribute.

use Spiral\Attribute\DispatcherScope;
use Spiral\Boot\DispatcherInterface;

#[DispatcherScope(scope: 'console')]
final class ConsoleDispatcher implements DispatcherInterface
{
    // ...
}
Registration of dispatchers

The registration of dispatchers has been changed. The accepted type in the addDispatcher method of the Spiral\Boot\AbstractKernel class has been extended from DispatcherInterface to string|DispatcherInterface. Before these changes, the method accepted a created DispatcherInterface object, now it can accept a class name string or an object. In version 4.0, the DispatcherInterface type will be removed. When passing an object, only its class name will be saved. And when using the dispatcher, its object will be created anew.

Example with ConsoleDispatcher:

public function init(AbstractKernel $kernel): void
{
    $kernel->bootstrapped(static function (AbstractKernel $kernel): void {
        $kernel->addDispatcher(ConsoleDispatcher::class);
    });
}
Using dispatchers

The dispatchers are now created in their own scope and receive dependencies that are specified in this scope. But due to the need to check whether the dispatcher can handle the request or not before creating the dispatcher object, the canServe method in dispatchers must be static:

public static function canServe(EnvironmentInterface $env): bool
{
    return (PHP_SAPI === 'cli' && $env->get('RR_MODE') === null);
}

This method has been removed from the Spiral\Boot\DispatcherInterface, for backward compatibility it can be non-static, as it was before (then an object will be created for its call) or static and accept Spiral\Boot\EnvironmentInterface.

4. Added scaffolder:info console command

Adds scaffolder:info console command by @butschster in https://github.com/spiral/framework/pull/1068

Now you can list available commands.

image

Other

New Contributors

Full Changelog: https://github.com/spiral/framework/compare/3.11.1...3.12.0

3.11.1

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.11.0...3.11.1

3.11.0

What's Changed

Other changes

Bugfixes

Full Changelog: https://github.com/spiral/framework/compare/3.10.1...3.11.0

3.10.1

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.10.0...3.10.1

3.10.0

Improvements

1. Improved the bootloader registration process

We've introduced a new interface, Spiral\Boot\Bootloader\BootloaderRegistryInterface, and its implementation, Spiral\Boot\Bootloader\BootloaderRegistry. This update makes the process of registering bootloaders in Spiral much simpler and more flexible.

Now, you can easily manage your bootloaders using our spiral-packages/discoverer package. This package helps you automatically find and register bootloaders specified in your composer.json like in example below:

{
  // ...
  "extra": {
    "spiral": {
      "bootloaders": [
        "Spiral\\Monolog\\Bootloader\\DotenvBootloader",
        "Spiral\\DotEnv\\Bootloader\\MonologBootloader"
      ],
      "dont-discover": [
        "spiral-packages/event-bus"
      ]
    }
  }
}

This feature also allows for bootloader discovery from various sources, such as configuration files or other custom methods.

by @msmakouz in https://github.com/spiral/framework/pull/1015

2. Enhanced Error Handling for Incorrect Data Types in Filters.

The spiral/filters package in Spiral's ecosystem is designed for filtering and, optionally, validating input data. It enables you to set specific rules for each input field, ensuring that the data received matches the expected format and other defined criteria.

For example, consider this filter:

namespace App\Endpoint\Web\Filter;

use Spiral\Filters\Attribute\Input\Query;
use Spiral\Filters\Model\Filter;

final class UserFilter extends Filter
{
    #[Query(key: 'username')]
    public string $username;
}

In this scenario, the username is expected to be a string. However, there might be instances where the input data is of the wrong type, such as an array or an integer. Previously, such mismatches would result in an exception being thrown by the application.

With the new update, we've added the capability to specify custom error messages for these mismatches. This enhancement allows for more graceful handling of incorrect data types. Here's how you can implement it:

namespace App\Endpoint\Web\Filter;

use Spiral\Filters\Attribute\Input\Query;
use Spiral\Filters\Model\Filter;
use Spiral\Filters\Attribute\CastingErrorMessage;

final class UserFilter extends Filter
{
    #[Query(key: 'username')]
    #[CastingErrorMessage('Invalid type')]
    public string $username;
}

This update ensures that your application can provide clearer feedback when encountering data of an unexpected type.

by @msmakouz in https://github.com/spiral/framework/pull/1016

3. Added the ability to configure bootloaders via BootloadConfig

There is a new DTO class Spiral\Boot\Attribute\BootloadConfig which enables the inclusion or exclusion of bootloaders, passing parameters that will be forwarded to the init and boot methods of the bootloader, and dynamically adjusting the bootloader loading based on environment variables.

Here is a simple example:

namespace App\Application;

use Spiral\Boot\Attribute\BootloadConfig;
use Spiral\Prototype\Bootloader\PrototypeBootloader;

class Kernel extends \Spiral\Framework\Kernel
{
    // ...
    public function defineBootloaders(): array
    {
        return [
            // ...
            PrototypeBootloader::class => new BootloadConfig(allowEnv: ['APP_ENV' => ['local', 'dev']]),
            // ...
        ];
    }
    
    // ...
}

In this example, we specified that the PrototypeBootloader should be loaded only if the environment variable APP_ENV is defined and has a value of local or dev.

You can also define a function that returns a BootloadConfig object. This function can take arguments, which might be obtained from the container.

PrototypeBootloader::class => static fn (AppEnvironment $env) => new BootloadConfig(enabled: $env->isLocal()),

You can also use BootloadConfig class as an attribute to control how a bootloader behaves.

use Spiral\Boot\Attribute\BootloadConfig;
use Spiral\Boot\Bootloader\Bootloader;

#[BootloadConfig(allowEnv: ['APP_ENV' => 'local'])]
final class SomeBootloader extends Bootloader
{
}

Attributes are a great choice when you want to keep the configuration close to the bootloader's code. It's a more intuitive way to set up bootloaders, especially in cases where the configuration is straightforward and doesn't require complex logic.

By extending BootloadConfig, you can create custom classes that encapsulate specific conditions under which bootloaders should operate.

Here's an example

class TargetRRWorker extends BootloadConfig {
    public function __construct(array $modes)
    {
        parent::__construct(
            env: ['RR_MODE' => $modes],
        );
    }
}

// ...

class Kernel extends Kernel
{
    public function defineBootloaders(): array
    {
        return [
            HttpBootloader::class => new TargetRRWorker(['http']),
            RoutesBootloader::class => new TargetRRWorker(['http']),
            // Other bootloaders...
        ];
    }
}

by @msmakouz in https://github.com/spiral/framework/pull/1017

Other changes

Bugfixes

Full Changelog: https://github.com/spiral/framework/compare/3.9.1...3.10

3.9.0

Improvements

1. Added RetryPolicyInterceptor for Queue component

Added Spiral\Queue\Interceptor\Consume\RetryPolicyInterceptor to enable automatic job retries with a configurable retry policy. To use it, need to add the Spiral\Queue\Attribute\RetryPolicy attribute to the job class:

use Spiral\Queue\Attribute\RetryPolicy;
use Spiral\Queue\JobHandler;

#[RetryPolicy(maxAttempts: 3, delay: 5, multiplier: 2)]
final class Ping extends JobHandler
{
    public function invoke(array $payload): void
    {
        // ...
    }
}

Create an exception that implements interface Spiral\Queue\Exception\RetryableExceptionInterface:

use Spiral\Queue\Exception\RetryableExceptionInterface;
use Spiral\Queue\RetryPolicyInterface;

class RetryException extends \DomainException implements RetryableExceptionInterface
{
    public function isRetryable(): bool
    {
        return true;
    }

    public function getRetryPolicy(): ?RetryPolicyInterface
    {
        return null;
    }
}

The exception must implement the two methods isRetryable and getRetryPolicy. These methods can override the retry behavior and cancel the re-queue- or change the retry policy.

If a RetryException is thrown while a job runs, the job will be re-queued according to the retry policy.

Pull request: https://github.com/spiral/framework/pull/980 by @msmakouz

2. Added the ability to configure serializer and job type for Queue component via attributes

Added ability to configure serializer and job type using attributes.

use App\Domain\User\Entity\User;
use Spiral\Queue\Attribute\Serializer;
use Spiral\Queue\Attribute\JobHandler as Handler;
use Spiral\Queue\JobHandler;

#[Handler('ping')]
#[Serializer('marshaller-json')]
final class Ping extends JobHandler
{
    public function invoke(User $payload): void
    {
        // ...
    }
}

Pull request: https://github.com/spiral/framework/pull/990 by @msmakouz

3. Added the ability to configure the Monolog messages format

Now you can configure the Monolog messages format via environment variable MONOLOG_FORMAT.

MONOLOG_FORMAT="[%datetime%] %level_name%: %message% %context%\n"

Pull request: https://github.com/spiral/framework/pull/994 by @msmakouz

4. Added the ability to register additional translation directories

Now you can register additional directories with translation files for the Translator component. This can be useful when developing additional packages for the Spiral Framework, where the package may provide translation files (for example, validators). Translation files in an application can override translations from additional directories.

A directory with translations can be registered via the Spiral\Bootloader\I18nBootloader bootloader or translator.php configuration file.

Via I18nBootloader bootloader

use Spiral\Boot\Bootloader\Bootloader;
use Spiral\Bootloader\I18nBootloader;

final class AppBootloader extends Bootloader
{
    public function init(I18nBootloader $i18n): void
    {
        $i18n->addDirectory('some/directory');
    }
}

Via configuration file

return [
    // ...
    'directories' => [
        'some/directory'
    ],
    // ...
];

Pull request: https://github.com/spiral/framework/pull/996 by @msmakouz

5. Added the ability to store snapshots using Storage component

Have you ever faced challenges in storing your app's exception snapshots when working with stateless applications? We've got some good news. With our latest update, we've made it super easy for you.

By integrating with the spiral/storage component, we're giving your stateless apps the power to save exception snapshots straight into S3.

Why is this awesome for you?

  1. Simplified Storage: No more juggling with complex storage solutions. Save snapshots directly to S3 with ease.
  2. Tailored for Stateless Apps: Designed specifically for stateless applications, making your deployments smoother and hassle-free.
  3. Reliability: With S3's proven track record, know your snapshots are stored safely and can be accessed whenever you need.

How to use:

  1. Switch to the new bootloader: Swap out Spiral\Bootloader\SnapshotsBootloader with Spiral\Bootloader\StorageSnapshotsBootloader.
  2. Set up your bucket for snapshot storage and specify the desired bucket using the SNAPSHOTS_BUCKET environment variable.
  3. Modify app/src/Application/Bootloader/ExceptionHandlerBootloader.php to replace the exception reporter Spiral\Exceptions\Reporter\FileReporter with Spiral\Exceptions\Reporter\StorageReporter in the boot method (an example for a default installation of spiral/app).

Pull request: https://github.com/spiral/framework/pull/986 by @msmakouz

6. Introduced new prototype:list console command for listing prototype dependencies

The prototype:list command is a super cool addition to our Spiral Framework. It helps developers by providing an easy way to list all the classes registered in the Spiral\Prototype\PrototypeRegistry. These registered classes are essential for project prototyping.

How to Use It

Using the command is simple. Just run the following line in your terminal:

php app.php prototype:list

Once you do that, you'll get a neat table that displays all the registered prototypes, including their names and target classes. This makes it incredibly easy to see what's available for your project prototyping needs.

+------------------+-------------------------------------------------------+
| Name:            | Target:                                               |
+------------------+-------------------------------------------------------+
| app              | App\Application\Kernel                                |
| classLocator     | Spiral\Tokenizer\ClassesInterface                     |
| console          | Spiral\Console\Console                                |
| broadcast        | Spiral\Broadcasting\BroadcastInterface                |
| container        | Psr\Container\ContainerInterface                      |
| encrypter        | Spiral\Encrypter\EncrypterInterface                   |
| env              | Spiral\Boot\EnvironmentInterface                      |
| files            | Spiral\Files\FilesInterface                           |
| guard            | Spiral\Security\GuardInterface                        |
| http             | Spiral\Http\Http                                      |
| i18n             | Spiral\Translator\TranslatorInterface                 |
| input            | Spiral\Http\Request\InputManager                      |
| session          | Spiral\Session\SessionScope                           |
| cookies          | Spiral\Cookies\CookieManager                          |
| logger           | Psr\Log\LoggerInterface                               |
| logs             | Spiral\Logger\LogsInterface                           |
| memory           | Spiral\Boot\MemoryInterface                           |
| paginators       | Spiral\Pagination\PaginationProviderInterface         |
| queue            | Spiral\Queue\QueueInterface                           |
| queueManager     | Spiral\Queue\QueueConnectionProviderInterface         |
| request          | Spiral\Http\Request\InputManager                      |
| response         | Spiral\Http\ResponseWrapper                           |
| router           | Spiral\Router\RouterInterface                         |
| snapshots        | Spiral\Snapshots\SnapshotterInterface                 |
| storage          | Spiral\Storage\BucketInterface                        |
| serializer       | Spiral\Serializer\SerializerManager                   |
| validator        | Spiral\Validation\ValidationInterface                 |
| views            | Spiral\Views\ViewsInterface                           |
| auth             | Spiral\Auth\AuthScope                                 |
| authTokens       | Spiral\Auth\TokenStorageInterface                     |
| cache            | Psr\SimpleCache\CacheInterface                        |
| cacheManager     | Spiral\Cache\CacheStorageProviderInterface            |
| exceptionHandler | Spiral\Exceptions\ExceptionHandlerInterface           |
| users            | App\Infrastructure\Persistence\CycleORMUserRepository |
+------------------+-------------------------------------------------------+

Why It Matters

This new feature enhances developer productivity and ensures that we're making the most of the Spiral Framework's capabilities. It provides clarity on available prototypes, which can be crucial when building and extending our projects.

Note You might notice that we've also renamed the old prototype:list command to prototype:usage to better align with its purpose.

Pull request: https://github.com/spiral/framework/pull/1003 by @msmakouz

Other changes

  1. [spiral/scaffolder] Changed Queue job handler payload type from array to mixed by @msmakouz in https://github.com/spiral/framework/pull/992
  2. [spiral/monolog-bridge] Set bubble as true by default in logRotate method by @msmakouz in https://github.com/spiral/framework/pull/997
  3. [spiral/prototype] Initialize PrototypeRegistry only when registry requires from container by @msmakouz in https://github.com/spiral/framework/pull/1005

Bug fixes

  1. [spiral/router] Fixed issue with Registering Routes Containing Host using RoutesBootloader by @msmakouz in https://github.com/spiral/framework/pull/990
  2. [spiral/reactor] Fix Psalm issues and tests in Reactor by @msmakouz in https://github.com/spiral/framework/pull/1002

Full Changelog: https://github.com/spiral/framework/compare/3.8.4...3.9.0

3.8.4

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.8.3...3.8.4

3.8.3

What's Changed

Full Changelog: https://github.com/spiral/framework/compare/3.8.2...3.8.3

Weaver

How can I help you explore Laravel packages today?

Conversation history is not saved when not logged in.
Prompt
Add packages to context
No packages found.
davejamesmiller/laravel-breadcrumbs
artisanry/parsedown
christhompsontldr/phpsdk
enqueue/dsn
bunny/bunny
enqueue/test
enqueue/null
enqueue/amqp-tools
milesj/emojibase
bower-asset/punycode
bower-asset/inputmask
bower-asset/jquery
bower-asset/yii2-pjax
laravel/nova
spatie/laravel-mailcoach
spatie/laravel-superseeder
laravel/liferaft
nst/json-test-suite
danielmiessler/sec-lists
jackalope/jackalope-transport