Addition of new middleware, RoutesBuilderMiddleware

.gitignore

@@ -4,3 +4,4 @@
 composer.lock
 phpunit.xml
 .phpunit.result.cache
+.DS_Store

docs/middlewares.md

@@ -2,15 +2,31 @@
 
 Middlewares are an optional bit of logic to transform the given data at various lifecycle points.
 
-### Path
+## Route generation
+### Routes
+
+To add a route middleware create a class that implements `\Vyuldashev\LaravelOpenApi\Contracts\RoutesBuilderMiddleware` then register it by referencing it in the  `openapi.collections.default.middlewares.paths` config array like `MyRouteMiddleware::class`
+
+Available lifecycle points are:
+- `after` - after the `RouteInformation` has been built.
+
+### Paths
 
 To add a path middleware create a class that implements `\Vyuldashev\LaravelOpenApi\Contracts\PathMiddleware` then register it by referencing it in the  `openapi.collections.default.middlewares.paths` config array like `MyPathMiddleware::class`
 
 Available lifecycle points are:
  - `before` - after collecting all `RouteInformation` but before processing them.
  - `after` - after the `PathItem` has been built.
 
-### Component
+## Component generation
+### Pre-component generation
+
+To add a path middleware create a class that implements `\Vyuldashev\LaravelOpenApi\Contracts\ComponentCreateMiddleware` then register it by referencing it in the  `openapi.collections.default.middlewares.components` config array like `MyComponentMiddleware::class`
+
+Available lifecycle points are:
+- `before` - before the `Components` has been built.
+
+### Post-component generation
 
 To add a path middleware create a class that implements `\Vyuldashev\LaravelOpenApi\Contracts\ComponentMiddleware` then register it by referencing it in the  `openapi.collections.default.middlewares.components` config array like `MyComponentMiddleware::class`
 

examples/petstore/OpenApi/Middlewares/InsertRequestBodyMiddleware.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Examples\Petstore\OpenApi\Middlewares;
+
+use Examples\Petstore\OpenApi\RequestBodies\EmptyRequestBody;
+use Vyuldashev\LaravelOpenApi\Attributes as OpenApi;
+use Vyuldashev\LaravelOpenApi\Contracts\RoutesBuilderMiddleware;
+use Vyuldashev\LaravelOpenApi\Generator;
+use Vyuldashev\LaravelOpenApi\RouteInformation;
+
+class InsertRequestBodyMiddleware implements RoutesBuilderMiddleware
+{
+    public function after(RouteInformation $routeInformation): RouteInformation
+    {
+        $routeInformation->actionAttributes[] = new OpenApi\RequestBody(EmptyRequestBody::class);
+        $routeInformation->actionAttributes[] = new OpenApi\Collection([Generator::COLLECTION_DEFAULT]);
+
+        return $routeInformation;
+    }
+}

examples/petstore/OpenApi/RequestBodies/EmptyRequestBody.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Examples\Petstore\OpenApi\RequestBodies;
+
+use GoldSpecDigital\ObjectOrientedOAS\Objects\RequestBody;
+use Vyuldashev\LaravelOpenApi\Factories\RequestBodyFactory;
+use Vyuldashev\LaravelOpenApi\RouteInformation;
+
+class EmptyRequestBody extends RequestBodyFactory
+{
+    private RouteInformation $routeInformation;
+
+    public function __construct(RouteInformation $routeInformation)
+    {
+        $this->routeInformation = $routeInformation;
+    }
+
+    public function build(): RequestBody
+    {
+        return RequestBody::create('EmptyRequestBody')
+            ->description('Empty '.$this->routeInformation->method.' body');
+    }
+}

src/Builders/ComponentsBuilder.php

@@ -8,7 +8,10 @@
 use Vyuldashev\LaravelOpenApi\Builders\Components\ResponsesBuilder;
 use Vyuldashev\LaravelOpenApi\Builders\Components\SchemasBuilder;
 use Vyuldashev\LaravelOpenApi\Builders\Components\SecuritySchemesBuilder;
+use Vyuldashev\LaravelOpenApi\Contracts\ComponentCreateMiddleware;
+use Vyuldashev\LaravelOpenApi\Contracts\ComponentMiddleware;
 use Vyuldashev\LaravelOpenApi\Generator;
+use Vyuldashev\LaravelOpenApi\Middleware;
 
 class ComponentsBuilder
 {
@@ -42,44 +45,38 @@ public function build(
         $schemas = $this->schemasBuilder->build($collection);
         $securitySchemes = $this->securitySchemesBuilder->build($collection);
 
-        $components = Components::create();
-
-        $hasAnyObjects = false;
+        $components = Middleware::make($middlewares)
+            ->using(ComponentCreateMiddleware::class)
+            ->send(Components::create())
+            ->through(fn ($middleware, $components) => $middleware->before($components));
 
         if (count($callbacks) > 0) {
-            $hasAnyObjects = true;
-
             $components = $components->callbacks(...$callbacks);
         }
 
         if (count($requestBodies) > 0) {
-            $hasAnyObjects = true;
-
             $components = $components->requestBodies(...$requestBodies);
         }
 
         if (count($responses) > 0) {
-            $hasAnyObjects = true;
             $components = $components->responses(...$responses);
         }
 
         if (count($schemas) > 0) {
-            $hasAnyObjects = true;
             $components = $components->schemas(...$schemas);
         }
 
         if (count($securitySchemes) > 0) {
-            $hasAnyObjects = true;
             $components = $components->securitySchemes(...$securitySchemes);
         }
 
-        if (! $hasAnyObjects) {
+        if (! count($components->toArray())) {
             return null;
         }
 
-        foreach ($middlewares as $middleware) {
-            app($middleware)->after($components);
-        }
+        Middleware::make($middlewares)
+            ->using(ComponentMiddleware::class)
+            ->emit(fn ($middleware) => $middleware->after($components));
 
         return $components;
     }

src/Builders/Paths/Operation/CallbacksBuilder.php

@@ -13,8 +13,8 @@ public function build(RouteInformation $route): array
     {
         return $route->actionAttributes
             ->filter(static fn (object $attribute) => $attribute instanceof CallbackAttribute)
-            ->map(static function (CallbackAttribute $attribute) {
-                $factory = app($attribute->factory);
+            ->map(static function (CallbackAttribute $attribute) use ($route) {
+                $factory = app($attribute->factory, ['routeInformation' => $route]);
                 $pathItem = $factory->build();
 
                 if ($factory instanceof Reusable) {

src/Builders/Paths/Operation/ParametersBuilder.php

@@ -61,7 +61,7 @@ protected function buildAttribute(RouteInformation $route): Collection
 
         if ($parameters) {
             /** @var ParametersFactory $parametersFactory */
-            $parametersFactory = app($parameters->factory);
+            $parametersFactory = app($parameters->factory, ['routeInformation' => $route]);
 
             $parameters = $parametersFactory->build();
         }

src/Builders/Paths/Operation/RequestBodyBuilder.php

@@ -17,7 +17,7 @@ public function build(RouteInformation $route): ?RequestBody
 
         if ($requestBody) {
             /** @var RequestBodyFactory $requestBodyFactory */
-            $requestBodyFactory = app($requestBody->factory);
+            $requestBodyFactory = app($requestBody->factory, ['routeInformation' => $route]);
 
             $requestBody = $requestBodyFactory->build();
 

src/Builders/Paths/Operation/ResponsesBuilder.php

@@ -13,8 +13,8 @@ public function build(RouteInformation $route): array
     {
         return $route->actionAttributes
             ->filter(static fn (object $attribute) => $attribute instanceof ResponseAttribute)
-            ->map(static function (ResponseAttribute $attribute) {
-                $factory = app($attribute->factory);
+            ->map(static function (ResponseAttribute $attribute) use ($route) {
+                $factory = app($attribute->factory, ['routeInformation' => $route]);
                 $response = $factory->build();
 
                 if ($factory instanceof Reusable) {

src/Builders/Paths/Operation/SecurityBuilder.php

@@ -13,12 +13,12 @@ public function build(RouteInformation $route): array
         return $route->actionAttributes
             ->filter(static fn (object $attribute) => $attribute instanceof OperationAttribute)
             ->filter(static fn (OperationAttribute $attribute) => isset($attribute->security))
-            ->map(static function (OperationAttribute $attribute) {
+            ->map(static function (OperationAttribute $attribute) use ($route) {
                 // return a null scheme if the security is set to ''
                 if ($attribute->security === '') {
                     return SecurityRequirement::create()->securityScheme(null);
                 }
-                $security = app($attribute->security);
+                $security = app($attribute->security, ['routeInformation' => $route]);
                 $scheme = $security->build();
 
                 return SecurityRequirement::create()->securityScheme($scheme);

src/Builders/PathsBuilder.php

@@ -3,24 +3,25 @@
 namespace Vyuldashev\LaravelOpenApi\Builders;
 
 use GoldSpecDigital\ObjectOrientedOAS\Objects\PathItem;
-use Illuminate\Routing\Route;
-use Illuminate\Routing\Router;
 use Illuminate\Support\Collection;
-use Vyuldashev\LaravelOpenApi\Attributes;
 use Vyuldashev\LaravelOpenApi\Attributes\Collection as CollectionAttribute;
 use Vyuldashev\LaravelOpenApi\Builders\Paths\OperationsBuilder;
 use Vyuldashev\LaravelOpenApi\Contracts\PathMiddleware;
 use Vyuldashev\LaravelOpenApi\Generator;
+use Vyuldashev\LaravelOpenApi\Middleware;
 use Vyuldashev\LaravelOpenApi\RouteInformation;
 
 class PathsBuilder
 {
     protected OperationsBuilder $operationsBuilder;
+    protected RoutesBuilder $routesBuilder;
 
     public function __construct(
-        OperationsBuilder $operationsBuilder
+        OperationsBuilder $operationsBuilder,
+        RoutesBuilder $routesBuilder
     ) {
         $this->operationsBuilder = $operationsBuilder;
+        $this->routesBuilder = $routesBuilder;
     }
 
     /**
@@ -32,7 +33,7 @@ public function build(
         string $collection,
         array $middlewares
     ): array {
-        return $this->routes()
+        return $this->routes($middlewares)
             ->filter(static function (RouteInformation $routeInformation) use ($collection) {
                 /** @var CollectionAttribute|null $collectionAttribute */
                 $collectionAttribute = collect()
@@ -44,12 +45,12 @@ public function build(
                     (! $collectionAttribute && $collection === Generator::COLLECTION_DEFAULT) ||
                     ($collectionAttribute && in_array($collection, $collectionAttribute->name, true));
             })
-            ->map(static function (RouteInformation $item) use ($middlewares) {
-                foreach ($middlewares as $middleware) {
-                    app($middleware)->before($item);
-                }
+            ->map(static function (RouteInformation $routeInformation) use ($middlewares) {
+                Middleware::make($middlewares)
+                    ->using(PathMiddleware::class)
+                    ->emit(fn ($middleware) => $middleware->before($routeInformation));
 
-                return $item;
+                return $routeInformation;
             })
             ->groupBy(static fn (RouteInformation $routeInformation) => $routeInformation->uri)
             ->map(function (Collection $routes, $uri) {
@@ -60,30 +61,17 @@ public function build(
                 return $pathItem->operations(...$operations);
             })
             ->map(static function (PathItem $item) use ($middlewares) {
-                foreach ($middlewares as $middleware) {
-                    $item = app($middleware)->after($item);
-                }
-
-                return $item;
+                return Middleware::make($middlewares)
+                    ->using(PathMiddleware::class)
+                    ->send($item)
+                    ->through(fn ($middleware, $item) => $middleware->after($item));
             })
             ->values()
             ->toArray();
     }
 
-    protected function routes(): Collection
+    protected function routes(array $middlewares): Collection
     {
-        /** @noinspection CollectFunctionInCollectionInspection */
-        return collect(app(Router::class)->getRoutes())
-            ->filter(static fn (Route $route) => $route->getActionName() !== 'Closure')
-            ->map(static fn (Route $route) => RouteInformation::createFromRoute($route))
-            ->filter(static function (RouteInformation $route) {
-                $pathItem = $route->controllerAttributes
-                    ->first(static fn (object $attribute) => $attribute instanceof Attributes\PathItem);
-
-                $operation = $route->actionAttributes
-                    ->first(static fn (object $attribute) => $attribute instanceof Attributes\Operation);
-
-                return $pathItem && $operation;
-            });
+        return $this->routesBuilder->build($middlewares);
     }
 }

src/Builders/RoutesBuilder.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Vyuldashev\LaravelOpenApi\Builders;
+
+use Illuminate\Routing\Route;
+use Illuminate\Routing\Router;
+use Illuminate\Support\Collection;
+use Vyuldashev\LaravelOpenApi\Attributes;
+use Vyuldashev\LaravelOpenApi\Contracts\RoutesBuilderMiddleware;
+use Vyuldashev\LaravelOpenApi\Middleware;
+use Vyuldashev\LaravelOpenApi\RouteInformation;
+
+class RoutesBuilder
+{
+    /**
+     * @var Router
+     */
+    protected Router $router;
+
+    /**
+     * @param  Router  $router
+     */
+    public function __construct(Router $router)
+    {
+        $this->router = $router;
+    }
+
+    /**
+     * @param  RoutesBuilderMiddleware[]  $middlewares
+     * @return Collection
+     */
+    public function build(array $middlewares): Collection
+    {
+        /** @noinspection CollectFunctionInCollectionInspection */
+        return collect($this->router->getRoutes())
+            ->filter(static fn (Route $route) => $route->getActionName() !== 'Closure')
+            ->map(static fn (Route $route) => RouteInformation::createFromRoute($route))
+            ->map(static function (RouteInformation $route) use ($middlewares): RouteInformation {
+                return Middleware::make($middlewares)
+                    ->using(RoutesBuilderMiddleware::class)
+                    ->send($route)
+                    ->through(fn ($middleware, $route) => $middleware->after($route));
+            })
+            ->filter(static function (RouteInformation $route): bool {
+                $pathItem = $route->controllerAttributes
+                    ->first(static fn (object $attribute) => $attribute instanceof Attributes\PathItem);
+
+                $operation = $route->actionAttributes
+                    ->first(static fn (object $attribute) => $attribute instanceof Attributes\Operation);
+
+                return $pathItem && $operation;
+            });
+    }
+}

src/Contracts/ComponentCreateMiddleware.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Vyuldashev\LaravelOpenApi\Contracts;
+
+use GoldSpecDigital\ObjectOrientedOAS\Objects\Components;
+
+interface ComponentCreateMiddleware
+{
+    public function before(Components $components): Components;
+}

src/Contracts/RoutesBuilderMiddleware.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Vyuldashev\LaravelOpenApi\Contracts;
+
+use Vyuldashev\LaravelOpenApi\RouteInformation;
+
+interface RoutesBuilderMiddleware
+{
+    public function after(RouteInformation $routeInformation): RouteInformation;
+}