eee

src/Base/AbstractHandler.php

@@ -12,33 +12,40 @@ abstract class AbstractHandler
 {
 
 
-    public int $offset = 0;
+	public int $offset = 0;
 
 
-    /**
+	/**
-     * @param array $middlewares
+	 * @param array   $middlewares
-     * @param Handler $handler
+	 * @param Handler $handler
-     * @throws
+	 *
-     */
+	 * @throws
-    public function __construct(public array $middlewares, public Handler $handler)
+	 */
-    {
+	public function __construct(public array $middlewares, public Handler $handler)
-    }
+	{
+	}
 
-    /**
-     * @param ServerRequestInterface $request
-     * @return ResponseInterface
-     * @throws
-     */
-    public function execute(ServerRequestInterface $request): ResponseInterface
-    {
-        if (!isset($this->middlewares[$this->offset])) {
-            return $this->handler->handle($request);
-        }
-        
-        $middleware   = $this->middlewares[$this->offset];
-        $this->offset += 1;
 
-        return ($middleware instanceof MiddlewareInterface ? $middleware : di($middleware))->process($request, $this);
+	/**
-    }
+	 * @param ServerRequestInterface $request
+	 *
+	 * @return ResponseInterface
+	 * @throws
+	 */
+	public function execute(ServerRequestInterface $request): ResponseInterface
+	{
+		if (!isset($this->middlewares[$this->offset])) {
+			return $this->handler->handle($request);
+		}
+
+		$middleware   = $this->middlewares[$this->offset];
+		$this->offset += 1;
+
+		if (!($middleware instanceof MiddlewareInterface)) {
+			$middleware = \Kiri::getDi()->get($middleware);
+		}
+
+		return $middleware->process($request, $this);
+	}
 
 }

src/Constrict/ConstrictResponse.php

@@ -7,6 +7,8 @@ use Kiri\Core\Help;
 use Kiri\Router\ContentType;
 use Kiri\Router\StreamResponse;
 use Psr\Http\Message\ResponseInterface;
+use Swoole\Http\Response;
+
 
 class ConstrictResponse extends Message implements ResponseInterface
 {
@@ -18,11 +20,18 @@ class ConstrictResponse extends Message implements ResponseInterface
     private string $reasonPhrase;
 
 
+    /**
+     * @var array|mixed
+     */
+    public array $headers = [];
+
+
     /**
      * @param ContentType|null $contentType
      */
     public function __construct(?ContentType $contentType = null)
     {
+        $this->headers = \config('response.headers', $this->headers);
         if ($contentType != null) {
             $this->withHeader('Content-Type', $contentType->toString());
         }
@@ -30,6 +39,25 @@ class ConstrictResponse extends Message implements ResponseInterface
     }
 
 
+    /**
+     * @param string $url
+     * @param array $params
+     * @param int $statusCode
+     * @return static
+     */
+    public function redirectTo(string $url, array $params = [], int $statusCode = 302): static
+    {
+        if (!empty($params)) {
+            $url .= '?' . http_build_query($params);
+        }
+
+        $this->withHeader('Location', $url);
+        $this->withStatus($statusCode);
+
+        return $this;
+    }
+
+
     /**
      * @param ContentType $contentType
      * @return $this
@@ -187,6 +215,10 @@ class ConstrictResponse extends Message implements ResponseInterface
      */
     public function end(object $response): void
     {
+        /** @var Response $response */
+        if (count($this->headers) > 0) foreach ($this->headers as $key => $header) {
+            $response->header($key, $header);
+        }
         $response->end($this->stream->getContents());
     }
 }

src/Format/ArrayFormat.php

@@ -9,14 +9,24 @@ use Psr\Http\Message\ResponseInterface;
 class ArrayFormat implements IFormat
 {
 
-    /**
+
-     * @param $result
+	/**
-     * @return ResponseInterface
+	 * @param ResponseInterface $response
-     */
+	 */
-    public function call($result): ResponseInterface
+	public function __construct(public ResponseInterface $response)
-    {
+	{
-        return di(ResponseInterface::class)->withBody(new Stream(json_encode($result, JSON_UNESCAPED_UNICODE)));
+	}
-    }
+
+
+	/**
+	 * @param $result
+	 *
+	 * @return ResponseInterface
+	 */
+	public function call($result): ResponseInterface
+	{
+		return $this->response->withBody(new Stream(json_encode($result, JSON_UNESCAPED_UNICODE)));
+	}
 
 
 }

src/Format/MixedFormat.php

@@ -9,7 +9,16 @@ use Psr\Http\Message\ResponseInterface;
 class MixedFormat implements IFormat
 {
 
-    /**
+
+	/**
+	 * @param ResponseInterface $response
+	 */
+	public function __construct(public ResponseInterface $response)
+	{
+	}
+
+
+	/**
      * @param mixed $result
      * @return ResponseInterface
      */
@@ -18,14 +27,13 @@ class MixedFormat implements IFormat
         if ($result instanceof ResponseInterface) {
             return $result;
         }
-        $response = Kiri::getDi()->get(ResponseInterface::class);
         if (is_object($result)) {
-            return $response->withBody(new Stream('[object]'));
+            return $this->response->withBody(new Stream('[object]'));
         }
         if (is_array($result)) {
-            return $response->withBody(new Stream(json_encode($result, JSON_UNESCAPED_UNICODE)));
+            return $this->response->withBody(new Stream(json_encode($result, JSON_UNESCAPED_UNICODE)));
         } else {
-            return $response->withBody(new Stream((string)$result));
+            return $this->response->withBody(new Stream((string)$result));
         }
     }
 

src/Format/NoBody.php

@@ -9,27 +9,36 @@ use Psr\Http\Message\ResponseInterface;
 class NoBody implements IFormat
 {
 
-    /**
+
-     * @param $result
+	/**
-     * @return ResponseInterface
+	 * @param ResponseInterface $response
-     */
+	 */
-    public function call($result): ResponseInterface
+	public function __construct(public ResponseInterface $response)
-    {
+	{
-        // TODO: Implement call() method.
+	}
-        $response = Kiri::getDi()->get(ResponseInterface::class);
+
-        if (request()->getMethod() === 'HEAD') {
+
-            return $response->withBody(new Stream());
+	/**
-        }
+	 * @param $result
-        if ($result instanceof ResponseInterface) {
+	 *
-            return $result;
+	 * @return ResponseInterface
-        }
+	 */
-        if (is_object($result)) {
+	public function call($result): ResponseInterface
-            return $response->withBody(new Stream('[object]'));
+	{
-        }
+		// TODO: Implement call() method.
-        if (is_array($result)) {
+		if (request()->getMethod() === 'HEAD') {
-            return $response->withBody(new Stream(json_encode($result, JSON_UNESCAPED_UNICODE)));
+			return $this->response->withBody(new Stream());
-        } else {
+		}
-            return $response->withBody(new Stream((string)$result));
+		if ($result instanceof ResponseInterface) {
-        }
+			return $result;
-    }
+		}
+		if (is_object($result)) {
+			return $this->response->withBody(new Stream('[object]'));
+		}
+		if (is_array($result)) {
+			return $this->response->withBody(new Stream(json_encode($result, JSON_UNESCAPED_UNICODE)));
+		} else {
+			return $this->response->withBody(new Stream((string)$result));
+		}
+	}
 }

src/Format/OtherFormat.php

@@ -9,13 +9,18 @@ use Psr\Http\Message\ResponseInterface;
 class OtherFormat implements IFormat
 {
 
-    /**
+
+	public function __construct(public ResponseInterface $response)
+	{
+	}
+
+	/**
      * @param mixed $result
      * @return ResponseInterface
      */
     public function call(mixed $result): ResponseInterface
     {
-        return di(ResponseInterface::class)->withBody(new Stream($result));
+        return $this->response->withBody(new Stream($result));
     }
 
 

src/Format/VoidFormat.php

@@ -8,14 +8,23 @@ use Psr\Http\Message\ResponseInterface;
 class VoidFormat implements IFormat
 {
 
-    /**
+
-     * @param $result
+	/**
-     * @return ResponseInterface
+	 * @param ResponseInterface $response
-     */
+	 */
-    public function call($result): ResponseInterface
+	public function __construct(public ResponseInterface $response)
-    {
+	{
-        // TODO: Implement call() method.
+	}
-        return di(ResponseInterface::class);
+
-    }
+	/**
+	 * @param $result
+	 *
+	 * @return ResponseInterface
+	 */
+	public function call($result): ResponseInterface
+	{
+		// TODO: Implement call() method.
+		return $this->response;
+	}
 
 }

src/Handler.php

@@ -49,7 +49,7 @@ class Handler implements RequestHandlerInterface
      */
     public function setRequestMethod(string $method): void
     {
-        if ($method == 'HEAD') {
+        if ($method == 'HEAD' || $method == 'OPTIONS') {
             $this->format = Kiri::getDi()->get(NoBody::class);
         }
     }

src/HttpRequestHandler.php

@@ -7,7 +7,6 @@ use Kiri\Router\Base\AbstractHandler;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\RequestHandlerInterface;
-use ReflectionException;
 
 class HttpRequestHandler extends AbstractHandler implements RequestHandlerInterface
 {

src/OnRequest.php

@@ -4,6 +4,8 @@ declare(strict_types=1);
 
 namespace Kiri\Router;
 
+use Kiri\Abstracts\CoordinatorManager;
+use Kiri\Coordinator;
 use Kiri\Di\Inject\Container;
 use Kiri\Di\Context;
 use Kiri\Di\Interface\ResponseEmitterInterface;
@@ -73,12 +75,14 @@ class OnRequest implements OnRequestInterface
      */
     public function onRequest(Request $request, Response $response): void
     {
-        /** @var CQ $PsrRequest */
         try {
-            $PsrRequest = $this->initRequestAndResponse($request);
+            /** @var CQ $PsrRequest */
+            Context::set(ResponseInterface::class, new ConstrictResponse($this->response->contentType));
+            $PsrRequest = Context::set(RequestInterface::class, CQ::builder($request));
 
-            $PsrResponse = $this->router->query($request->server['path_info'], $request->getMethod())
+            CoordinatorManager::utility(Coordinator::WORKER_START)->yield();
-                                        ->run($PsrRequest);
+
+            $PsrResponse = $this->router->query($request->server['path_info'], $request->getMethod())->run($PsrRequest);
         } catch (Throwable $throwable) {
             $PsrResponse = $this->exception->emit($throwable, $this->constrictResponse);
         } finally {
@@ -86,18 +90,4 @@ class OnRequest implements OnRequestInterface
         }
     }
 
-
-    /**
-     * @param Request $request
-     * @return ServerRequestInterface
-     */
-    public function initRequestAndResponse(Request $request): ServerRequestInterface
-    {
-        $response = new ConstrictResponse($this->response->contentType);
-
-        Context::set(ResponseInterface::class, $response);
-
-        return Context::set(RequestInterface::class, CQ::builder($request));
-    }
-
 }

src/Response.php

@@ -68,6 +68,16 @@ class Response implements ResponseInterface
         return $this->__call__(__FUNCTION__, $content, $statusCode);
     }
 
+    /**
+     * @param string $url
+     * @param array $params
+     * @param int $statusCode
+     * @return ResponseInterface
+     */
+    public function redirectTo(string $url, array $params = [], int $statusCode = 302): ResponseInterface
+    {
+        return $this->__call__(__FUNCTION__, $url, $params, $statusCode);
+    }
 
     /**
      * @param array $content

src/Router.php

@@ -4,11 +4,15 @@ declare(strict_types=1);
 namespace Kiri\Router;
 
 use Closure;
+use Kiri\Server\Events\OnWorkerStart;
 use Kiri;
+use Kiri\Abstracts\CoordinatorManager;
+use Kiri\Coordinator;
 use Kiri\Router\Validator\ValidatorMiddleware;
 use Kiri\Router\Base\Middleware as MiddlewareManager;
 use Kiri\Router\Constrict\RequestMethod;
 use Psr\Container\ContainerInterface;
+use Psr\Http\Message\ResponseInterface;
 
 /**
  *
@@ -23,215 +27,230 @@ class Router
 {
 
 
-    const array METHODS = [RequestMethod::REQUEST_POST, RequestMethod::REQUEST_GET, RequestMethod::REQUEST_OPTIONS, RequestMethod::REQUEST_DELETE, RequestMethod::REQUEST_PUT, RequestMethod::REQUEST_HEAD];
+	const array METHODS = [RequestMethod::REQUEST_POST, RequestMethod::REQUEST_GET, RequestMethod::REQUEST_OPTIONS, RequestMethod::REQUEST_DELETE, RequestMethod::REQUEST_PUT, RequestMethod::REQUEST_HEAD];
 
 
-    /**
+	/**
-     * @var string
+	 * @var string
-     */
+	 */
-    private static string $type = ROUTER_TYPE_HTTP;
+	private static string $type = ROUTER_TYPE_HTTP;
 
 
-    /**
+	/**
-     * @param string $name
+	 * @param string  $name
-     * @param Closure $closure
+	 * @param Closure $closure
-     */
+	 */
-    public static function addServer(string $name, Closure $closure): void
+	public static function addServer(string $name, Closure $closure): void
-    {
+	{
-        static::$type = $name;
+		static::$type = $name;
-        $closure();
+		$closure();
-        static::$type = ROUTER_TYPE_HTTP;
+		static::$type = ROUTER_TYPE_HTTP;
-    }
+	}
 
 
-    /**
+	/**
-     * @param Closure $handler
+	 * @param Closure $handler
-     */
+	 */
-    public static function jsonp(Closure $handler): void
+	public static function jsonp(Closure $handler): void
-    {
+	{
-        static::$type = 'json-rpc';
+		static::$type = 'json-rpc';
-        $handler();
+		$handler();
-        static::$type = ROUTER_TYPE_HTTP;
+		static::$type = ROUTER_TYPE_HTTP;
-    }
+	}
 
 
-    /**
+	/**
-     * @param string $route
+	 * @param string $route
-     * @param string $handler
+	 * @param string $handler
-     * @throws
+	 *
-     */
+	 * @throws
-    public static function post(string $route, string $handler): void
+	 */
-    {
+	public static function post(string $route, string $handler): void
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+	{
-        $router->addRoute([RequestMethod::REQUEST_POST], $route, $handler);
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
-    }
+		$router->addRoute([RequestMethod::REQUEST_POST], $route, $handler);
+	}
 
-    /**
+	/**
-     * @param string $route
+	 * @param string $route
-     * @param string $handler
+	 * @param string $handler
-     * @throws
+	 *
-     */
+	 * @throws
-    public static function get(string $route, string $handler): void
+	 */
-    {
+	public static function get(string $route, string $handler): void
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+	{
-        $router->addRoute([RequestMethod::REQUEST_GET], $route, $handler);
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
-    }
+		$router->addRoute([RequestMethod::REQUEST_GET], $route, $handler);
+	}
 
 
-    /**
+	/**
-     * @param string $route
+	 * @param string $route
-     * @param string $handler
+	 * @param string $handler
-     * @throws
+	 *
-     */
+	 * @throws
-    public static function options(string $route, string $handler): void
+	 */
-    {
+	public static function options(string $route, string $handler): void
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+	{
-        $router->addRoute([RequestMethod::REQUEST_OPTIONS], $route, $handler);
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
-    }
+		$router->addRoute([RequestMethod::REQUEST_OPTIONS], $route, $handler);
+	}
 
 
-    /**
+	/**
-     * @param string $route
+	 * @param string $route
-     * @param string $handler
+	 * @param string $handler
-     * @throws
+	 *
-     */
+	 * @throws
-    public static function any(string $route, string $handler): void
+	 */
-    {
+	public static function any(string $route, string $handler): void
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+	{
-        $router->addRoute(self::METHODS, $route, $handler);
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
-    }
+		$router->addRoute(self::METHODS, $route, $handler);
+	}
 
-    /**
+	/**
-     * @param string $route
+	 * @param string $route
-     * @param string $handler
+	 * @param string $handler
-     * @throws
+	 *
-     */
+	 * @throws
-    public static function delete(string $route, string $handler): void
+	 */
-    {
+	public static function delete(string $route, string $handler): void
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+	{
-        $router->addRoute([RequestMethod::REQUEST_DELETE], $route, $handler);
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
-    }
+		$router->addRoute([RequestMethod::REQUEST_DELETE], $route, $handler);
+	}
 
 
-    /**
+	/**
-     * @param string $route
+	 * @param string $route
-     * @param string $handler
+	 * @param string $handler
-     * @throws
+	 *
-     */
+	 * @throws
-    public static function head(string $route, string $handler): void
+	 */
-    {
+	public static function head(string $route, string $handler): void
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+	{
-        $router->addRoute([RequestMethod::REQUEST_HEAD], $route, $handler);
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
-    }
+		$router->addRoute([RequestMethod::REQUEST_HEAD], $route, $handler);
+	}
 
 
-    /**
+	/**
-     * @param string $route
+	 * @param string $route
-     * @param string $handler
+	 * @param string $handler
-     * @throws
+	 *
-     */
+	 * @throws
-    public static function put(string $route, string $handler): void
+	 */
-    {
+	public static function put(string $route, string $handler): void
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+	{
-        $router->addRoute([RequestMethod::REQUEST_PUT], $route, $handler);
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
-    }
+		$router->addRoute([RequestMethod::REQUEST_PUT], $route, $handler);
+	}
 
 
-    /**
+	/**
-     * @param array|RequestMethod $methods
+	 * @param array|RequestMethod $methods
-     * @param string $route
+	 * @param string              $route
-     * @param string|array $handler
+	 * @param string|array        $handler
-     */
+	 */
-    public static function addRoute(array|RequestMethod $methods, string $route, string|array $handler): void
+	public static function addRoute(array|RequestMethod $methods, string $route, string|array $handler): void
-    {
+	{
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
-        if ($methods instanceof RequestMethod) {
+		if ($methods instanceof RequestMethod) {
-            $methods = [$methods];
+			$methods = [$methods];
-        }
+		}
-        $router->addRoute($methods, $route, $handler);
+		$router->addRoute($methods, $route, $handler);
-    }
+	}
 
 
-    /**
+	/**
-     * @param array $config
+	 * @param array   $config
-     * @param Closure $closure
+	 * @param Closure $closure
-     * @throws
+	 *
-     */
+	 * @throws
-    public static function group(array $config, Closure $closure): void
+	 */
-    {
+	public static function group(array $config, Closure $closure): void
-        $router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
+	{
+		$router = Kiri::getDi()->get(DataGrip::class)->get(static::$type);
 
-        $router->groupTack[] = $config;
+		$router->groupTack[] = $config;
 
-        call_user_func($closure);
+		call_user_func($closure);
 
-        array_pop($router->groupTack);
+		array_pop($router->groupTack);
-    }
+	}
 
 
-    /**
+	/**
-     * @throws
+	 * @throws
-     */
+	 */
-    public function scan_build_route(): void
+	public function scan_build_route(): void
-    {
+	{
-        $this->read_dir_file(APP_PATH . 'routes');
+		$coordinator = CoordinatorManager::utility(Coordinator::WORKER_START);
 
-        $container = Kiri::getDi();
+		$this->read_dir_file(APP_PATH . 'routes');
-        $scanner   = di(Kiri\Di\Scanner::class);
+
-        $scanner->load_directory(APP_PATH . 'app/Controller');
+		$container = Kiri::getDi();
-        $this->reset($container);
+		$scanner   = $container->get(Kiri\Di\Scanner::class);
-    }
+		$scanner->load_directory(APP_PATH . 'app/Controller');
+		$this->reset($container);
+
+		$coordinator->done();
+	}
 
 
-    /**
+	/**
-     * @param ContainerInterface $container
+	 * @param ContainerInterface $container
-     * @return void
+	 *
-     * @throws
+	 * @return void
-     */
+	 * @throws
-    public function reset(ContainerInterface $container): void
+	 */
-    {
+	public function reset(ContainerInterface $container): void
-        $router     = $container->get(DataGrip::class)->get(static::$type);
+	{
-        foreach ($router->getMethods() as $name => $method) {
+		$router = $container->get(DataGrip::class)->get(static::$type);
-            $middlewares = MiddlewareManager::get($method->getClass(), $method->getMethod());
+		foreach ($router->getMethods() as $name => $method) {
-            $validator   = MiddlewareManager::getValidator($method->getClass(), $method->getMethod());
+			$middlewares = MiddlewareManager::get($method->getClass(), $method->getMethod());
-            if (!is_null($validator)) {
+			$validator   = MiddlewareManager::getValidator($method->getClass(), $method->getMethod());
-                array_unshift($middlewares, new ValidatorMiddleware($method->getClass(), $method->getMethod()));
+			if (!is_null($validator)) {
-            }
+				array_unshift($middlewares, new ValidatorMiddleware(di(ResponseInterface::class), $method->getClass(), $method->getMethod()));
-            $router->setHttpHandler($name, new HttpRequestHandler($middlewares, $method));
+			}
-        }
+			$router->setHttpHandler($name, new HttpRequestHandler($middlewares, $method));
-    }
+		}
+	}
 
 
-    /**
+	/**
-     * @param $path
+	 * @param $path
-     * @return void
+	 *
-     * @throws
+	 * @return void
-     */
+	 * @throws
-    private function read_dir_file($path): void
+	 */
-    {
+	private function read_dir_file($path): void
-        $files = glob($path . '/*');
+	{
-        for ($i = 0; $i < count($files); $i++) {
+		$files = glob($path . '/*');
-            $file = $files[$i];
+		for ($i = 0; $i < count($files); $i++) {
-            if (is_dir($file)) {
+			$file = $files[$i];
-                $this->read_dir_file($file);
+			if (is_dir($file)) {
-            } else {
+				$this->read_dir_file($file);
-                $this->resolve_file($file);
+			} else {
-            }
+				$this->resolve_file($file);
-        }
+			}
-    }
+		}
+	}
 
 
-    /**
+	/**
-     * @param $files
+	 * @param $files
-     * @throws
+	 *
-     */
+	 * @throws
-    private function resolve_file($files): void
+	 */
-    {
+	private function resolve_file($files): void
-        try {
+	{
-            include "$files";
+		try {
-        } catch (\Throwable $throwable) {
+			include "$files";
-            error($throwable);
+		} catch (\Throwable $throwable) {
-        }
+			error($throwable);
-    }
+		}
+	}
 
 }

src/SwooleHttpResponseEmitter.php

@@ -3,16 +3,13 @@ declare(strict_types=1);
 
 namespace Kiri\Router;
 
-use Kiri\Di\Inject\Container;
 use Kiri\Di\Interface\ResponseEmitterInterface;
 use Kiri\Events\EventDispatch;
 use Kiri\Events\EventProvider;
 use Kiri\Server\Events\OnAfterRequest;
-use Psr\Container\ContainerExceptionInterface;
-use Psr\Container\NotFoundExceptionInterface;
 use Psr\Http\Message\ResponseInterface;
-use ReflectionException;
 use SplPriorityQueue;
+use function swoole_version;
 
 
 /**
@@ -69,6 +66,7 @@ class SwooleHttpResponseEmitter implements ResponseEmitterInterface
      */
     private function writeParams(ResponseInterface $proxy, object $response, object $request): void
     {
+        /** @var \Swoole\Http\Response $response */
         $response->setStatusCode($proxy->getStatusCode());
         $headers = $proxy->getHeaders();
         if (count($headers) > 0) foreach ($headers as $name => $header) {
@@ -78,9 +76,9 @@ class SwooleHttpResponseEmitter implements ResponseEmitterInterface
         if (count($cookieParams) > 0) foreach ($cookieParams as $cookie) {
             $response->setCookie(...$cookie);
         }
-        $response->header('Run-Time', $this->getRunTime($request));
+        $response->header('Run-Time', $this->getRunTime($request) . '');
         $response->header('Server', 'swoole');
-        $response->header('Swoole-Version', \swoole_version());
+        $response->header('Swoole-Version', swoole_version());
     }
 
 

src/Validator/ValidatorMiddleware.php

@@ -17,11 +17,12 @@ class ValidatorMiddleware implements MiddlewareInterface
 {
 
 
-    /**
+	/**
-     * @param string $class
+	 * @param ResponseInterface $response
-     * @param string $method
+	 * @param string            $class
-     */
+	 * @param string            $method
-    public function __construct(public string $class, public string $method)
+	 */
+    public function __construct(public ResponseInterface $response ,public string $class, public string $method)
     {
     }
 
@@ -38,7 +39,7 @@ class ValidatorMiddleware implements MiddlewareInterface
         if (!$validator->run($request)) {
             Kiri::getLogger()->println($request->getUri()->getPath() . ' `' . $validator->error() . '`');
 
-            return di(ResponseInterface::class)->html($validator->error(), 415);
+            return $this->response->html($validator->error(), 415);
         } else {
             return $handler->handle($request);
         }