Merge pull request #22 from marcelthole/resolve-9

Add option to disable the resolving of dependencies

Author: marcelthole

.editorconfig

@@ -13,3 +13,7 @@ trim_trailing_whitespace = false
 
 [*.{yaml, yml, neon, neon.dist, json, json.dist}]
 indent_size = 2
+
+[tests/*/Fixtures/expected/*.json]
+indent_size = 4
+insert_final_newline = false

.github/workflows/build.yml

@@ -61,6 +61,10 @@ jobs:
       - name: "Show dependencies"
         run: "composer show"
 
+      - name: "Run code style check"
+        run: "composer run-script cs-check"
+        if: ${{ matrix.composer-deps == 'latest' && matrix.php-version == '7.4' }}
+
       - name: "Run CI"
         run: "composer run-script ci"
 

bin/openapi-merge

@@ -4,6 +4,7 @@
 use Mthole\OpenApiMerge\Console\Command\MergeCommand;
 use Mthole\OpenApiMerge\Merge\PathMerger;
 use Mthole\OpenApiMerge\OpenApiMerge;
+use Mthole\OpenApiMerge\Merge\ReferenceNormalizer;
 use Mthole\OpenApiMerge\Reader\FileReader;
 use Mthole\OpenApiMerge\Writer\DefinitionWriter;
 use Symfony\Component\Console\Application;
@@ -24,7 +25,11 @@ use Symfony\Component\Console\Application;
 
 $application = new Application();
 $application->add(new MergeCommand(
-    new OpenApiMerge(new FileReader(), new PathMerger()),
+    new OpenApiMerge(
+        new FileReader(),
+        new PathMerger(),
+        new ReferenceNormalizer()
+    ),
     new DefinitionWriter()
 ));
 $application->setDefaultCommand(MergeCommand::COMMAND_NAME, true);

composer.json

@@ -38,16 +38,21 @@
   },
   "scripts": {
     "ci": [
-      "@cs-check",
       "@phpunit",
       "@phpstan"
     ],
     "ci-coverage": [
       "@phpunit-coverage",
       "@infection"
     ],
-    "cs-check": "phpcs",
-    "cs-fix": "phpcbf",
+    "cs-check": [
+      "phpcs --config-set php_version 70423",
+      "phpcs -s"
+    ],
+    "cs-fix": [
+      "phpcs --config-set php_version 70423",
+      "phpcbf"
+    ],
     "phpunit": "@php -dzend.assertions=1 ./vendor/bin/phpunit --no-coverage",
     "phpunit-coverage": "@php -dxdebug.mode=coverage -dzend.assertions=1 ./vendor/bin/phpunit",
     "phpstan": "phpstan analyse",

src/Console/Command/MergeCommand.php

@@ -54,6 +54,13 @@ protected function configure(): void
             )
             ->addArgument('basefile', InputArgument::REQUIRED)
             ->addArgument('additionalFiles', InputArgument::IS_ARRAY)
+            ->addOption(
+                'resolve-references',
+                null,
+                InputOption::VALUE_OPTIONAL,
+                'Resolve the "$refs" in the given files',
+                true
+            )
             ->addOption(
                 'outputfile',
                 'o',
@@ -71,12 +78,15 @@ protected function execute(InputInterface $input, OutputInterface $output): int
             throw new Exception('Invalid arguments given');
         }
 
+        $shouldResolveReferences = (bool) $input->getOption('resolve-references');
+
         $mergedResult = $this->merger->mergeFiles(
             new File($baseFile),
-            ...array_map(
+            array_map(
                 static fn (string $file): File => new File($file),
                 $additionalFiles
-            )
+            ),
+            $shouldResolveReferences,
         );
 
         $outputFileName = $input->getOption('outputfile');
@@ -88,10 +98,10 @@ protected function execute(InputInterface $input, OutputInterface $output): int
                 $mergedResult->getOpenApi()
             );
             file_put_contents(
-                $outputFile->getAbsolutePath(),
+                $outputFile->getAbsoluteFile(),
                 $this->definitionWriter->write($specificationFile)
             );
-            $output->writeln(sprintf('File successfully written to %s', $outputFile->getAbsolutePath()));
+            $output->writeln(sprintf('File successfully written to %s', $outputFile->getAbsoluteFile()));
         } else {
             $output->write($this->definitionWriter->write($mergedResult));
         }

src/FileHandling/File.php

@@ -6,6 +6,7 @@
 
 use Mthole\OpenApiMerge\FileHandling\Exception\IOException;
 
+use function dirname;
 use function getcwd;
 use function pathinfo;
 use function realpath;
@@ -28,7 +29,7 @@ public function getFileExtension(): string
         return pathinfo($this->filename, PATHINFO_EXTENSION);
     }
 
-    public function getAbsolutePath(): string
+    public function getAbsoluteFile(): string
     {
         $fullFilename = realpath($this->filename);
         if ($fullFilename === false) {
@@ -40,6 +41,11 @@ public function getAbsolutePath(): string
         return $fullFilename;
     }
 
+    public function getAbsolutePath(): string
+    {
+        return dirname($this->getAbsoluteFile());
+    }
+
     private function createAbsoluteFilePath(string $filename): string
     {
         if (strpos($filename, '/') === 0) {

src/Merge/ReferenceNormalizer.php

@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mthole\OpenApiMerge\Merge;
+
+use cebe\openapi\spec\MediaType;
+use cebe\openapi\spec\OpenApi;
+use cebe\openapi\spec\Reference;
+use cebe\openapi\spec\Response;
+use Mthole\OpenApiMerge\FileHandling\File;
+
+use function array_map;
+use function assert;
+use function count;
+use function preg_match;
+
+use const DIRECTORY_SEPARATOR;
+
+class ReferenceNormalizer
+{
+    public function normalizeInlineReferences(
+        File $openApiFile,
+        OpenApi $openApiDefinition
+    ): ReferenceResolverResult {
+        $refFileCollection = [];
+        foreach ($openApiDefinition->paths as $path) {
+            foreach ($path->getOperations() as $operation) {
+                assert($operation->responses !== null);
+                foreach ($operation->responses->getResponses() as $statusCode => $response) {
+                    if ($response instanceof Reference) {
+                        $operation->responses->addResponse(
+                            $statusCode,
+                            $this->normalizeReference($response, $refFileCollection)
+                        );
+                    }
+
+                    if (! ($response instanceof Response)) {
+                        continue;
+                    }
+
+                    foreach ($response->content as $responseContent) {
+                        assert($responseContent instanceof MediaType);
+                        if ($responseContent->schema instanceof Reference) {
+                            $responseContent->schema = $this->normalizeReference(
+                                $responseContent->schema,
+                                $refFileCollection
+                            );
+                        }
+
+                        $newExamples = [];
+                        foreach ($responseContent->examples as $key => $example) {
+                            if ($example instanceof Reference) {
+                                $newExamples[$key] = $this->normalizeReference(
+                                    $example,
+                                    $refFileCollection
+                                );
+                            } elseif ($example !== null) {
+                                $newExamples[$key] = $example;
+                            }
+                        }
+
+                        if (count($newExamples) <= 0) {
+                            continue;
+                        }
+
+                        $responseContent->examples = $newExamples;
+                    }
+                }
+            }
+        }
+
+        return new ReferenceResolverResult(
+            $openApiDefinition,
+            $this->normalizeFilePaths($openApiFile, $refFileCollection)
+        );
+    }
+
+    /**
+     * @param array<int, string> $refFileCollection
+     */
+    private function normalizeReference(Reference $reference, array &$refFileCollection): Reference
+    {
+        $matches       = [];
+        $referenceFile = $reference->getReference();
+        if (preg_match('~^(?<referenceFile>.*)(?<referenceString>#/.*)~', $referenceFile, $matches) === 1) {
+            $refFile = $matches['referenceFile'];
+
+            $refFileCollection[] = $refFile;
+
+            return new Reference(['$ref' => $matches['referenceString']]);
+        }
+
+        return $reference;
+    }
+
+    /**
+     * @param array<int, string> $refFileCollection
+     *
+     * @return array<int, File>
+     */
+    private function normalizeFilePaths(File $openApiFile, array $refFileCollection): array
+    {
+        return array_map(
+            static fn (string $refFile): File => new File(
+                $openApiFile->getAbsolutePath() . DIRECTORY_SEPARATOR . $refFile
+            ),
+            $refFileCollection
+        );
+    }
+}

src/Merge/ReferenceResolverResult.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mthole\OpenApiMerge\Merge;
+
+use cebe\openapi\spec\OpenApi;
+use Mthole\OpenApiMerge\FileHandling\File;
+
+final class ReferenceResolverResult
+{
+    private OpenApi $openApiSpecification;
+    /** @var array<int, File> */
+    private array $foundReferenceFiles;
+
+    /**
+     * @param array<int, File> $foundReferenceFiles
+     */
+    public function __construct(
+        OpenApi $openApiSpecification,
+        array $foundReferenceFiles
+    ) {
+        $this->openApiSpecification = $openApiSpecification;
+        $this->foundReferenceFiles  = $foundReferenceFiles;
+    }
+
+    public function getNormalizedDefinition(): OpenApi
+    {
+        return $this->openApiSpecification;
+    }
+
+    /** @return array<int, File> */
+    public function getFoundReferenceFiles(): array
+    {
+        return $this->foundReferenceFiles;
+    }
+}

src/OpenApiMerge.php

@@ -4,38 +4,72 @@
 
 namespace Mthole\OpenApiMerge;
 
+use cebe\openapi\spec\Components;
 use Mthole\OpenApiMerge\FileHandling\File;
 use Mthole\OpenApiMerge\FileHandling\SpecificationFile;
 use Mthole\OpenApiMerge\Merge\PathMergerInterface;
+use Mthole\OpenApiMerge\Merge\ReferenceNormalizer;
 use Mthole\OpenApiMerge\Reader\FileReader;
 
+use function array_merge;
+use function array_push;
+use function count;
+
 class OpenApiMerge implements OpenApiMergeInterface
 {
     private FileReader $openApiReader;
 
     private PathMergerInterface $pathMerger;
+    private ReferenceNormalizer $referenceNormalizer;
 
     public function __construct(
         FileReader $openApiReader,
-        PathMergerInterface $pathMerger
+        PathMergerInterface $pathMerger,
+        ReferenceNormalizer $referenceResolver
     ) {
-        $this->openApiReader = $openApiReader;
-        $this->pathMerger    = $pathMerger;
+        $this->openApiReader       = $openApiReader;
+        $this->pathMerger          = $pathMerger;
+        $this->referenceNormalizer = $referenceResolver;
     }
 
-    public function mergeFiles(File $baseFile, File ...$additionalFiles): SpecificationFile
+    /** @param array<int, File> $additionalFiles */
+    public function mergeFiles(File $baseFile, array $additionalFiles, bool $resolveReference = true): SpecificationFile
     {
-        $mergedOpenApiDefinition = $this->openApiReader->readFile($baseFile)->getOpenApi();
+        $mergedOpenApiDefinition = $this->openApiReader->readFile($baseFile, $resolveReference)->getOpenApi();
+
+        // use "for" instead of "foreach" to iterate over new added files
+        for ($i = 0; $i < count($additionalFiles); $i++) {
+            $additionalFile       = $additionalFiles[$i];
+            $additionalDefinition = $this->openApiReader->readFile($additionalFile, $resolveReference)->getOpenApi();
+            if (! $resolveReference) {
+                $resolvedReferenceResult = $this->referenceNormalizer->normalizeInlineReferences(
+                    $additionalFile,
+                    $additionalDefinition
+                );
+                array_push($additionalFiles, ...$resolvedReferenceResult->getFoundReferenceFiles());
+                $additionalDefinition = $resolvedReferenceResult->getNormalizedDefinition();
+            }
 
-        foreach ($additionalFiles as $additionalFile) {
-            $additionalDefinition           = $this->openApiReader->readFile($additionalFile)->getOpenApi();
             $mergedOpenApiDefinition->paths = $this->pathMerger->mergePaths(
                 $mergedOpenApiDefinition->paths,
                 $additionalDefinition->paths
             );
+
+            if ($additionalDefinition->components === null) {
+                continue;
+            }
+
+            if ($mergedOpenApiDefinition->components === null) {
+                $mergedOpenApiDefinition->components = new Components([]);
+            }
+
+            $mergedOpenApiDefinition->components->schemas = array_merge(
+                $mergedOpenApiDefinition->components->schemas ?? [],
+                $additionalDefinition->components->schemas ?? []
+            );
         }
 
-        if ($mergedOpenApiDefinition->components !== null) {
+        if ($resolveReference && $mergedOpenApiDefinition->components !== null) {
             $mergedOpenApiDefinition->components->schemas = [];
         }
 

src/OpenApiMergeInterface.php

@@ -9,5 +9,10 @@
 
 interface OpenApiMergeInterface
 {
-    public function mergeFiles(File $baseFile, File ...$additionalFiles): SpecificationFile;
+    /** @param array<int, File> $additionalFiles */
+    public function mergeFiles(
+        File $baseFile,
+        array $additionalFiles,
+        bool $resolveReference = true
+    ): SpecificationFile;
 }