Providing Authorize button in Swagger UI with externalized Open API

[NadChel]

Suppose I have a server that retrieves an Open API from somewhere else. How do I enable the Authorize button in Swagger UI? All I need is to be able to pass a JWT as an Authorization request header

Here's an MRE. Stapi is completely open, but let's imagine that it's actually some microservice and the Swagger UI server is a gateway (which is the case). It's even called "Gateway" even though it actually isn't. Also, keep in mind that the Open API for Stapi that I found is apparently stale. You won't be able to actually hit any of those endpoints (even from your browser)

That said, I'm open to suggestions involving editing the source code of the server that supplies API documentation (I have write access to the actual microservice)

package com.example.gatewaydemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class GatewaydemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewaydemoApplication.class, args);
    }

}

package com.example.gatewaydemo.service;

import io.swagger.v3.oas.models.OpenAPI;
import reactor.core.publisher.Mono;

public interface ApiProvider {
    String getApiName();
    Mono<OpenAPI> getOpenApi();
}

package com.example.gatewaydemo.config;

import com.example.gatewaydemo.service.ApiProvider;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.parser.OpenAPIV3Parser;
import io.swagger.v3.parser.core.models.SwaggerParseResult;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.ExchangeStrategies;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Configuration
public class ApiProviderConfig {
    @Bean
    public WebClient webClient() {
        int size = 16 * 1024 * 1024;
        ExchangeStrategies strategies = ExchangeStrategies.builder()
                .codecs(codecs -> codecs.defaultCodecs().maxInMemorySize(size))
                .build();
        return WebClient.builder()
                .exchangeStrategies(strategies)
                .build();
    }

    @Bean
    public OpenAPIV3Parser openApiParser() {
        return new OpenAPIV3Parser();
    }

    @Bean
    public ApiProvider stapiApiProvider(WebClient webClient, OpenAPIV3Parser parser) {
        return new ApiProvider() {
            @Override
            public String getApiName() {
                return "stapi";
            }

            @Override
            public Mono<OpenAPI> getOpenApi() {
                return webClient.get()
                        .uri("https://stapi.co/api/v1/rest/common/download/stapi.yaml")
                        .retrieve()
                        .bodyToMono(String.class)
                        .map(parser::readContents)
                        .map(SwaggerParseResult::getOpenAPI);
            }
        };
    }
}

package com.example.gatewaydemo.config;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ObjectMapperConfig {
    @Bean
    public ObjectMapper nullIgnoringObjectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return objectMapper;
    }
}

package com.example.gatewaydemo.controller;

import com.example.gatewaydemo.model.SwaggerUiConfig;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@RestController
public class SwaggerUiConfigController {
    @GetMapping("/swagger-ui/config")
    public Mono<SwaggerUiConfig> getSwaggerUiConfig() {
        return Mono.just(SwaggerUiConfig.builder()
                .withConfigItemOf().url("/swagger-ui/doc/stapi").name("Star Trek API").build()
                .build());
    }
}

package com.example.gatewaydemo.controller;

import com.example.gatewaydemo.service.ApiProvider;
import io.swagger.v3.oas.models.OpenAPI;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

import java.util.List;

@RestController
@RequiredArgsConstructor
public class SwaggerUiDocController {
    private final List<ApiProvider> apiProviders;
    @GetMapping("/swagger-ui/doc/{api-name}")
    public Mono<OpenAPI> getOpenApi(@PathVariable("api-name") String apiName) {
        return apiProviders.stream()
                .filter(apiProvider -> apiProvider.getApiName().equals(apiName))
                .findFirst()
                .orElseThrow()
                .getOpenApi();
    }
}

package com.example.gatewaydemo.model;

import lombok.Getter;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;

@NoArgsConstructor
@Getter
public class SwaggerUiConfig {
    private final List<ConfigItem> urls = new ArrayList<>();

    public SwaggerUiConfig(SwaggerUiConfigBuilder builder) {
        this.urls.addAll(builder.getUrls());
    }

    public static SwaggerUiConfigBuilder builder() {
        return new SwaggerUiConfigBuilder();
    }

    @Getter
    public static class SwaggerUiConfigBuilder {
        private final List<ConfigItem> urls = new ArrayList<>();

        public ConfigItem.ConfigItemBuilder withConfigItemOf() {
            return new ConfigItem.ConfigItemBuilder(this);
        }

        public SwaggerUiConfig build() {
            return new SwaggerUiConfig(this);
        }
    }

    @NoArgsConstructor
    @Getter
    public static class ConfigItem {
        private String url;
        private String name;

        private ConfigItem(ConfigItemBuilder builder) {
            this.url = builder.getUrl();
            this.name = builder.getName();
        }

        @Getter
        public static class ConfigItemBuilder {
            private final SwaggerUiConfigBuilder configBuilderInstance;
            private String url;
            private String name;

            ConfigItemBuilder(SwaggerUiConfigBuilder configBuilderInstance) {
                this.configBuilderInstance = configBuilderInstance;
            }

            public ConfigItemBuilder url(String url) {
                this.url = url;
                return this;
            }

            public ConfigItemBuilder name(String name) {
                this.name = name;
                return this;
            }

            public SwaggerUiConfigBuilder build() {
                ConfigItem configItem = new ConfigItem(this);
                configBuilderInstance.urls.add(configItem);
                return configBuilderInstance;
            }
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>gatewaydemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>gatewaydemo</name>
    <description>gatewaydemo</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>

        <dependency>
            <groupId>io.swagger.parser.v3</groupId>
            <artifactId>swagger-parser</artifactId>
            <version>2.1.18</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
            <version>2.0.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

springdoc:
  swagger-ui:
    config-url: /swagger-ui/config
    path: /swagger-ui

Hit http://localhost:8080/swagger-ui and you should be able to see this. No Authorize button. I want it