feat: swagger

Author: liutao

src/Application.php

@@ -40,13 +40,17 @@ public static function boot(): Application
     }
 
     /**
+     * @param OutputInterface $output
+     * @return Application
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
      * @throws ReflectionException
      */
     public function run(OutputInterface $output): Application
     {
         $app = new Application();
-        $config = $app->init();
-        $app->listen($config, $output);
+        $app->init();
+        $app->listen($output);
 
         return $app;
     }
@@ -73,21 +77,24 @@ public static function getClass(string $class)
     /**
      * @throws ReflectionException
      */
-    private function init(): array
+    private function init(): void
     {
         Env::load();
         $this->initContainer();
         $config = $this->getConfig();
         $this->initDatabase($config['database']);
         $this->scanAttributes($config['app']['scanner']);
-
-        return $config;
+        $router = $this->getRouter($config['routes']);
+        Application::getContainer()->add(Router::class, $router);
     }
 
-    private function listen(array $config, OutputInterface $output): void
+    /**
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
+     */
+    private function listen(OutputInterface $output): void
     {
-        $router = $this->getRouter($config['routes']);
-        Application::getContainer()->add(Router::class, $router);
+        $router = Application::getContainer()->get(Router::class);
         ServerFactory::newServer()->run($router, $output);
     }
 

src/Commands/StartCommand.php

@@ -70,9 +70,11 @@ private function roadrunnerStart(OutputInterface $output, ServerConfig $serverCo
     }
 
     /**
+     * @param OutputInterface $output
+     * @return int
      * @throws ContainerExceptionInterface
-     * @throws ReflectionException
      * @throws NotFoundExceptionInterface
+     * @throws ReflectionException
      */
     private function workermanStart(OutputInterface $output): int
     {
@@ -82,9 +84,11 @@ private function workermanStart(OutputInterface $output): int
     }
 
     /**
+     * @param OutputInterface $output
+     * @return int
      * @throws ContainerExceptionInterface
-     * @throws ReflectionException
      * @throws NotFoundExceptionInterface
+     * @throws ReflectionException
      */
     private function swooleStart(OutputInterface $output): int
     {

src/Commands/SwaggerGenerateCommand.php

@@ -0,0 +1,26 @@
+<?php
+declare(strict_types=1);
+
+namespace MicroPHP\Framework\Commands;
+
+use MicroPHP\Framework\Attribute\Attributes\CMD;
+use MicroPHP\Swagger\Swagger;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+#[CMD]
+class SwaggerGenerateCommand extends Command
+{
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        Swagger::gen();
+        $output->writeln('<info>swagger was generated</info>');
+        return Command::SUCCESS;
+    }
+
+    protected function configure(): void
+    {
+        $this->setName('swagger:gen')->setDescription('Generate swagger file');
+    }
+}

src/ConfigProvider.php

@@ -6,6 +6,7 @@
 
 use MicroPHP\Framework\Commands\PublishConfigCommand;
 use MicroPHP\Framework\Commands\StartCommand;
+use MicroPHP\Framework\Commands\SwaggerGenerateCommand;
 use MicroPHP\Framework\Config\ConfigProviderInterface;
 
 class ConfigProvider implements ConfigProviderInterface
@@ -16,6 +17,7 @@ public function config(): array
             'commands' => [
                 StartCommand::class,
                 PublishConfigCommand::class,
+                SwaggerGenerateCommand::class,
             ],
         ];
     }

src/Router/Route.php

@@ -0,0 +1,12 @@
+<?php
+declare(strict_types=1);
+
+namespace MicroPHP\Framework\Router;
+
+class Route extends \League\Route\Route
+{
+    public function getHandler(): array|string|callable|object
+    {
+        return $this->handler;
+    }
+}

src/Router/Router.php

@@ -5,6 +5,7 @@
 namespace MicroPHP\Framework\Router;
 
 use League\Route\RouteGroup;
+use League\Route\Strategy\OptionsHandlerInterface;
 
 class Router extends \League\Route\Router
 {
@@ -15,4 +16,51 @@ public function getOrPost(string $path, $handler): RouteGroup
             $group->post($path, $handler);
         });
     }
+
+    /**
+     * @return Route[]
+     */
+    public function getRoutes(): array
+    {
+        return $this->routes;
+    }
+
+    public function map(string $method, string $path, $handler): Route
+    {
+        $path  = sprintf('/%s', ltrim($path, '/'));
+        $route = new Route($method, $path, $handler);
+
+        $this->routes[] = $route;
+
+        return $route;
+    }
+
+    protected function buildOptionsRoutes(array $options): void
+    {
+        if (!($this->getStrategy() instanceof OptionsHandlerInterface)) {
+            return;
+        }
+
+        /** @var OptionsHandlerInterface $strategy */
+        $strategy = $this->getStrategy();
+
+        foreach ($options as $identifier => $methods) {
+            [$scheme, $host, $port, $path] = explode(static::IDENTIFIER_SEPARATOR, $identifier);
+            $route = new Route('OPTIONS', $path, $strategy->getOptionsCallable($methods));
+
+            if (!empty($scheme)) {
+                $route->setScheme($scheme);
+            }
+
+            if (!empty($host)) {
+                $route->setHost($host);
+            }
+
+            if (!empty($port)) {
+                $route->setPort((int)$port);
+            }
+
+            $this->routeCollector->addRoute($route->getMethod(), $this->parseRoutePath($route->getPath()), $route);
+        }
+    }
 }

src/Swagger/PathGetter.php

@@ -0,0 +1,32 @@
+<?php
+declare(strict_types=1);
+
+namespace MicroPHP\Framework\Swagger;
+
+use MicroPHP\Framework\Application;
+use MicroPHP\Framework\Router\Router;
+use MicroPHP\Swagger\Contract\PathGetterInterface;
+use MicroPHP\Swagger\Enum\MethodEnum;
+use Psr\Container\ContainerExceptionInterface;
+use Psr\Container\NotFoundExceptionInterface;
+
+class PathGetter implements PathGetterInterface
+{
+    /**
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
+     */
+    public static function getPath(string $controller, string $function, MethodEnum $requestMethod = null):?string {
+        /** @var Router $route */
+        $route = Application::getContainer()->get(Router::class);
+        foreach ($route->getRoutes() as $route) {
+            $handler = $route->getHandler();
+            if (is_array($handler)) {
+                if ($controller === $handler[0] && $function === $handler[1]) {
+                    return $route->getPath();
+                }
+            }
+        }
+        return null;
+    }
+}