NEW: support for external middleware adapter & container.

Author: hsehszroc

Src/Pipeline.php

@@ -43,7 +43,7 @@ final public static function resolve( string|Closure|Pipe $pipe ): Closure {
 
 		return match ( true ) {
 			default                  => throw InvalidPipeError::from( $pipe ),
-			$isClassName             => self::make( $pipe )->handle( ... ),
+			$isClassName             => PipelineBridge::make( $pipe )->handle( ... ),
 			$pipe instanceof Pipe    => $pipe->handle( ... ),
 			$pipe instanceof Closure => $pipe,
 		};
@@ -172,10 +172,4 @@ public function thenReturn() {
 	protected function chain( Closure $next, string|Closure|Pipe $current ): Closure {
 		return fn ( $subject ) => self::resolve( $current )( $subject, $next, ...( $this->use ?? array() ) );
 	}
-
-	private static function make( string $pipe ): Pipe {
-		return function_exists( '\\TheWebSolver\\Codegarage\\app' )
-			? \TheWebSolver\Codegarage\app()->make( $pipe )
-			: new $pipe();
-	}
 }

Src/PipelineBridge.php

@@ -22,33 +22,42 @@
 class PipelineBridge {
 	public const MIDDLEWARE_RESPONSE = 'middlewareResponse';
 
+	/** @phpstan-param class-string */
+	private static string $middlewareInterface;
+	/** @phpstan-param class-string */
+	private static string $middlewareClass;
+	/** @var \Psr\Container\ContainerInterface */
+	private static object $container;
+
 	/**
 	 * @param string|Pipe|Closure(mixed $subject, Closure $next, mixed ...$use): mixed $from
 	 * @throws InvalidPipeError When invalid pipe given.
 	 */
 	public static function toPipe( string|Closure|Pipe $from ): Pipe {
-		return new class( $from ) implements Pipe {
-			public function __construct( private readonly string|Closure|Pipe $pipe ) {}
+		$pipe = Pipeline::resolve( pipe: $from );
+
+		return new class( $pipe ) implements Pipe {
+			public function __construct( private readonly Closure $pipe ) {}
 
 			/**
 			 * @param mixed         $subject
 			 * @param Closure(mixed $subject, mixed ...$use): mixed $next
 			 */
 			public function handle( mixed $subject, Closure $next, mixed ...$use ): mixed {
-				return $next( Pipeline::resolve( $this->pipe )( $subject, $next, ...$use ) );
+				return $next( ( $this->pipe )( $subject, $next, ...$use ) );
 			}
 		};
 	}
 
 	/**
-	 * @param string|Closure|Middleware $middleware
-	 * @return Middleware
-	 * @throws LogicException When invoked on projects that doesn't implement PSR7 & PSR15
+	 * @throws LogicException When invoked on projects that doesn't implement PSR7 & PSR15.
 	 * @throws TypeError When middleware creation fails due to invalid classname.
 	 * @throws Throwable When unknown error occurs.
 	 */
-	public static function toMiddleware( $middleware ) {
-		$interface = '\\Psr\\Http\\Server\\MiddlewareInterface';
+	public static function toMiddleware( mixed $middleware ): object {
+		$interface = static::hasMiddlewareInterfaceAdapter()
+			? static::$middlewareInterface
+			: '\\Psr\\Http\\Server\\MiddlewareInterface';
 
 		if ( ! interface_exists( $interface ) ) {
 			throw new LogicException(
@@ -62,10 +71,10 @@ public static function toMiddleware( $middleware ) {
 		try {
 			$middleware = ( match ( true ) {
 				// Middleware classname is a non-existing classname, then default to null.
-				default                           => null,
-				$middleware instanceof Closure    => $middleware,
-				$isClassName                      => ( new $middleware() )->process( ... ),
-				$middleware instanceof Middleware => $middleware->process( ... ),
+				default                         => null,
+				$middleware instanceof Closure  => $middleware,
+				$isClassName                    => static::make( $middleware )->process( ... ),
+				is_a( $middleware, $interface ) => $middleware->process( ... ),
 			} );
 
 			if ( null === $middleware ) {
@@ -74,18 +83,12 @@ public static function toMiddleware( $middleware ) {
 						'Non-existing class "%1$s". Middleware must be a Closure, an instance of %2$s'
 						. ' or classname of a class that implements %2$s.',
 						$provided,
-						$interface
+						static::$middlewareInterface
 					)
 				);
 			}
 
-			return new class( $middleware ) implements Middleware {
-				public function __construct( private readonly Closure $middleware ) {}
-
-				public function process( Request $request, Handler $handler ): Response {
-					return ( $this->middleware )( $request, $handler );
-				}
-			};
+			return static::getMiddlewareAdapter( $middleware );
 		} catch ( Throwable $e ) {
 			if ( ! is_string( $middleware ) ) {
 				throw $e;
@@ -95,22 +98,62 @@ public function process( Request $request, Handler $handler ): Response {
 				sprintf(
 					'The given middleware classname: "%1$s" must be an instance of "%2$s".',
 					$middleware,
-					$interface
+					static::$middlewareInterface
 				)
 			);
 		}//end try
 	}
 
 	/** @param string|Closure|Middleware $middleware */
 	public static function middlewareToPipe( $middleware ): Pipe {
+		// Because Pipe::handle() wraps this function with the next pipe, we do not need to...
+		// ...manually wrap middleware with $next & let createPipe take care of it.
+		// If we do so, same middleware will recreate response multiple times
+		// making our app less performant which we don't want at all cost.
 		return self::toPipe(
-			// Because Pipe::handle() wraps this function with the next pipe, we do not need to...
-			static fn ( Response $r, Closure $next, Request $request, Handler $handler ) =>
-				// ...manually wrap middleware with $next & let createPipe take care of it.
-				// If we do so, same middleware will recreate response multiple times
-				// making our app less performant which we don't want at all cost.
-				self::toMiddleware( $middleware )
-					->process( $request->withAttribute( self::MIDDLEWARE_RESPONSE, $r ), $handler )
+			static fn ( $r, $next, $request, $handler ) => self::toMiddleware( $middleware )
+				->process( $request->withAttribute( static::MIDDLEWARE_RESPONSE, $r ), $handler )
 		);
 	}
+
+	public static function make( string $className ): object {
+		return isset( static::$container ) && static::$container->has( id: $className )
+			? static::$container->get( id: $className )
+			: new $className();
+	}
+
+	/** @param \Psr\Container\ContainerInterface $container */
+	public static function setApp( object $container ): void {
+		static::$container = $container;
+	}
+
+	public static function setMiddlewareAdapter( string $interface, string $className ): void {
+		static::$middlewareInterface = $interface;
+		static::$middlewareClass     = $className;
+	}
+
+	public static function resetMiddlewareAdapter(): void {
+		static::$middlewareInterface = '';
+		static::$middlewareClass     = '';
+	}
+
+	private static function getMiddlewareAdapter( Closure $middleware ): object {
+		return static::hasMiddlewareClassAdapter()
+			? new static::$middlewareClass( $middleware )
+			: new class( $middleware ) implements Middleware {
+				public function __construct( private readonly Closure $middleware ) {}
+
+				public function process( Request $request, Handler $handler ): Response {
+					return ( $this->middleware )( $request, $handler );
+				}
+			};
+	}
+
+	private static function hasMiddlewareInterfaceAdapter(): bool {
+		return isset( static::$middlewareInterface ) && interface_exists( static::$middlewareInterface );
+	}
+
+	private static function hasMiddlewareClassAdapter(): bool {
+		return isset( static::$middlewareClass ) && class_exists( static::$middlewareClass );
+	}
 }