@ahmttyydn/java-integration 1.0.1

package/scalar-webflux/src/main/java/com/scalar/maven/webflux/ScalarWebFluxAutoConfiguration.java

@@ -0,0 +1,63 @@
+package com.scalar.maven.webflux;
+
+import org.springframework.boot.actuate.autoconfigure.endpoint.condition.ConditionalOnAvailableEndpoint;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Auto-configuration for the Scalar API Reference integration in Spring WebFlux applications.
+ *
+ * <p>
+ * This class provides automatic configuration for the Scalar API Reference
+ * in Spring Boot WebFlux applications. It automatically creates the necessary beans
+ * when the scalar integration is enabled.
+ * </p>
+ *
+ * <p>
+ * The auto-configuration is conditional on the {@code scalar.enabled} property
+ * being set to {@code true} (which is the default).
+ * </p>
+ *
+ * <p>
+ * This configuration:
+ * </p>
+ * <ul>
+ * <li>Enables configuration properties via {@link SpringBootScalarProperties}</li>
+ * <li>Creates a {@link ScalarWebFluxController} bean for serving the API reference</li>
+ * <li>Creates a {@link ScalarWebFluxActuatorEndpoint} bean when actuator is enabled</li>
+ * </ul>
+ */
+@Configuration
+@EnableConfigurationProperties(SpringBootScalarProperties.class)
+@ConditionalOnProperty(prefix = "scalar", name = "enabled", havingValue = "true", matchIfMissing = true)
+public class ScalarWebFluxAutoConfiguration {
+
+    /**
+     * Creates a ScalarWebFluxController bean.
+     *
+     * @return a configured ScalarWebFluxController instance
+     */
+    @Bean
+    @ConditionalOnMissingBean(ScalarWebFluxController.class)
+    public ScalarWebFluxController scalarWebFluxController() {
+        return new ScalarWebFluxController();
+    }
+
+    /**
+     * Creates a ScalarWebFluxActuatorEndpoint bean when actuator support is enabled.
+     * This endpoint exposes the Scalar UI at /actuator/scalar.
+     *
+     * @return a configured ScalarWebFluxActuatorEndpoint instance
+     */
+    @Bean
+    @ConditionalOnProperty(prefix = "scalar", name = "actuatorEnabled", havingValue = "true")
+    @ConditionalOnClass(name = "org.springframework.boot.actuate.endpoint.annotation.Endpoint")
+    @ConditionalOnAvailableEndpoint(endpoint = ScalarWebFluxActuatorEndpoint.class)
+    public ScalarWebFluxActuatorEndpoint scalarWebFluxActuatorEndpoint() {
+        return new ScalarWebFluxActuatorEndpoint();
+    }
+}

package/scalar-webflux/src/main/java/com/scalar/maven/webflux/ScalarWebFluxController.java

@@ -0,0 +1,109 @@
+package com.scalar.maven.webflux;
+
+import com.scalar.maven.core.ScalarConstants;
+import com.scalar.maven.core.ScalarHtmlRenderer;
+import com.scalar.maven.core.ScalarProperties;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.core.io.ByteArrayResource;
+import org.springframework.core.io.Resource;
+import org.springframework.http.MediaType;
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * REST controller for serving the Scalar API Reference interface in Spring WebFlux applications.
+ *
+ * <p>
+ * This controller provides endpoints for accessing the Scalar API Reference
+ * interface and the associated JavaScript bundle. It automatically configures
+ * the interface based on the provided {@link ScalarProperties}.
+ * </p>
+ *
+ * <p>
+ * The controller serves two main endpoints:
+ * </p>
+ * <ul>
+ * <li>{@code /scalar} (or custom path) - The main API Reference interface</li>
+ * <li>{@code /scalar/scalar.js} (or custom path) - The JavaScript bundle</li>
+ * </ul>
+ *
+ * <p>
+ * This controller can be extended to customize behavior by overriding the
+ * {@link #configureProperties(ScalarProperties, ServerHttpRequest)} method.
+ * </p>
+ */
+@RestController
+@ConditionalOnMissingBean(ScalarWebFluxController.class)
+public class ScalarWebFluxController {
+
+    @Autowired
+    private ObjectProvider<SpringBootScalarProperties> propertiesProvider;
+
+    /**
+     * Serves the main API Reference interface.
+     *
+     * <p>
+     * This endpoint returns an HTML page that displays the Scalar API Reference
+     * interface. The page is configured with the OpenAPI specification URL from
+     * the properties.
+     * </p>
+     *
+     * @param request the HTTP request
+     * @return a Mono containing a Resource with the HTML content for the API Reference
+     * interface
+     */
+    @GetMapping(value = "${scalar.path:/scalar}", produces = MediaType.TEXT_HTML_VALUE)
+    public final Mono<Resource> getDocs(ServerHttpRequest request) {
+        return Mono.fromCallable(() -> {
+                    ScalarProperties properties = propertiesProvider.getObject();
+                    ScalarProperties configuredProperties = configureProperties(properties, request);
+                    String html = ScalarHtmlRenderer.render(configuredProperties);
+                    Resource resource = new ByteArrayResource(html.getBytes(StandardCharsets.UTF_8));
+                    return resource;
+                })
+                .subscribeOn(Schedulers.boundedElastic())
+                .onErrorMap(IOException.class, e -> new RuntimeException("Failed to render HTML", e));
+    }
+
+    /**
+     * Serves the JavaScript bundle for the Scalar API Reference.
+     *
+     * <p>
+     * This endpoint returns the JavaScript file that powers the Scalar API
+     * Reference interface. The file is served with the appropriate MIME type.
+     * </p>
+     *
+     * @return a Mono containing a Resource with the JavaScript bundle
+     */
+    @GetMapping(value = "${scalar.path:/scalar}/" + ScalarConstants.JS_FILENAME, produces = "application/javascript")
+    public final Mono<Resource> getScalarJs() {
+        return Mono.fromCallable(() -> {
+                    byte[] jsContent = ScalarHtmlRenderer.getScalarJsContent();
+                    Resource resource = new ByteArrayResource(jsContent);
+                    return resource;
+                })
+                .subscribeOn(Schedulers.boundedElastic())
+                .onErrorMap(IOException.class, e -> new RuntimeException("Failed to load JavaScript bundle", e));
+    }
+
+    /**
+     * Hook method that allows subclasses to configure properties before rendering.
+     * Override this method to customize the ScalarProperties before they are
+     * converted to JSON and rendered.
+     *
+     * @param properties the properties to configure
+     * @param request    the HTTP request
+     * @return the configured properties
+     */
+    protected ScalarProperties configureProperties(ScalarProperties properties, ServerHttpRequest request) {
+        return properties;
+    }
+}

package/scalar-webflux/src/main/java/com/scalar/maven/webflux/SpringBootScalarProperties.java

@@ -0,0 +1,43 @@
+package com.scalar.maven.webflux;
+
+import com.scalar.maven.core.ScalarProperties;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Scope;
+
+/**
+ * Spring Boot configuration properties wrapper for Scalar API Reference integration.
+ *
+ * <p>
+ * This class extends {@link ScalarProperties} and adds Spring Boot's
+ * {@link ConfigurationProperties} annotation to enable automatic property binding
+ * from Spring Boot configuration files (e.g., application.properties, application.yml).
+ * </p>
+ *
+ * <p>
+ * This wrapper allows the core {@link ScalarProperties} class to remain
+ * framework-agnostic while providing Spring Boot-specific functionality in the
+ * WebFlux integration module.
+ * </p>
+ *
+ * <p>
+ * Example usage in application.properties:
+ * </p>
+ *
+ * <pre>
+ * scalar.url=https://example.com/openapi.json
+ * scalar.path=/docs
+ * scalar.enabled=true
+ * scalar.showSidebar=true
+ * scalar.hideModels=false
+ * scalar.darkMode=true
+ * scalar.theme=default
+ * scalar.layout=modern
+ * </pre>
+ */
+@ConfigurationProperties(prefix = "scalar")
+@Scope("prototype")
+public class SpringBootScalarProperties extends ScalarProperties {
+    // All functionality is inherited from ScalarProperties
+    // This class only adds the @ConfigurationProperties annotation
+}
+

package/scalar-webflux/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -0,0 +1,2 @@
+com.scalar.maven.webflux.ScalarWebFluxAutoConfiguration
+

package/scalar-webflux/src/test/java/com/scalar/maven/webflux/ScalarWebFluxActuatorEndpointTest.java

@@ -0,0 +1,136 @@
+package com.scalar.maven.webflux;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.core.io.Resource;
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.test.util.ReflectionTestUtils;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("ScalarWebFluxActuatorEndpoint")
+class ScalarWebFluxActuatorEndpointTest {
+
+    @Mock
+    private SpringBootScalarProperties properties;
+
+    @Mock
+    private ObjectProvider<SpringBootScalarProperties> propertiesProvider;
+
+    @Mock
+    private ServerHttpRequest request;
+
+    private ScalarWebFluxActuatorEndpoint endpoint;
+
+    @BeforeEach
+    void setUp() {
+        lenient().when(propertiesProvider.getObject()).thenReturn(properties);
+        endpoint = new ScalarWebFluxActuatorEndpoint();
+        ReflectionTestUtils.setField(endpoint, "propertiesProvider", propertiesProvider);
+    }
+
+    @Nested
+    @DisplayName("Scalar UI Endpoint")
+    class ScalarUiEndpoint {
+
+        @Test
+        @DisplayName("should return HTML with default configuration")
+        void shouldReturnHtmlWithDefaultConfiguration() {
+            // Given
+            when(properties.getUrl()).thenReturn("https://registry.scalar.com/@scalar/apis/galaxy?format=json");
+            when(properties.getPageTitle()).thenReturn("Scalar API Reference");
+            when(properties.getPath()).thenReturn("/scalar");
+
+            // When
+            Mono<Resource> resourceMono = endpoint.scalarUi(request);
+
+            // Then
+            StepVerifier.create(resourceMono)
+                    .assertNext(resource -> {
+                        assertThat(resource).isNotNull();
+                        assertThat(resource.exists()).isTrue();
+                        try {
+                            String html = new String(resource.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+                            assertThat(html)
+                                    .contains("<!doctype html>")
+                                    .contains("<title>Scalar API Reference</title>")
+                                    .contains("Scalar.createApiReference('#app',");
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+                    .verifyComplete();
+        }
+
+        @Test
+        @DisplayName("should return HTML with custom URL")
+        void shouldReturnHtmlWithCustomUrl() {
+            // Given
+            when(properties.getUrl()).thenReturn("https://example.com/api/openapi.json");
+            when(properties.getPageTitle()).thenReturn("Scalar API Reference");
+            when(properties.getPath()).thenReturn("/scalar");
+
+            // When
+            Mono<Resource> resourceMono = endpoint.scalarUi(request);
+
+            // Then
+            StepVerifier.create(resourceMono)
+                    .assertNext(resource -> {
+                        assertThat(resource).isNotNull();
+                        assertThat(resource.exists()).isTrue();
+                        try {
+                            String html = new String(resource.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+                            assertThat(html)
+                                    .contains("<!doctype html>")
+                                    .contains("<title>Scalar API Reference</title>");
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+                    .verifyComplete();
+        }
+    }
+
+    @Nested
+    @DisplayName("JavaScript Endpoint")
+    class JavaScriptEndpoint {
+
+        @Test
+        @DisplayName("should return JavaScript file with correct content type")
+        void shouldReturnJavaScriptFileWithCorrectContentType() {
+            // When
+            Mono<Resource> resourceMono = endpoint.scalarJs();
+
+            // Then
+            StepVerifier.create(resourceMono)
+                    .assertNext(resource -> {
+                        assertThat(resource).isNotNull();
+                        assertThat(resource.exists()).isTrue();
+                        try {
+                            byte[] content = resource.getInputStream().readAllBytes();
+                            assertThat(content)
+                                    .isNotNull()
+                                    .isNotEmpty();
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+                    .verifyComplete();
+        }
+    }
+}
+

package/scalar-webflux/src/test/java/com/scalar/maven/webflux/ScalarWebFluxControllerTest.java

@@ -0,0 +1,162 @@
+package com.scalar.maven.webflux;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.core.io.Resource;
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.test.util.ReflectionTestUtils;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("ScalarWebFluxController")
+class ScalarWebFluxControllerTest {
+
+    @Mock
+    private SpringBootScalarProperties properties;
+
+    @Mock
+    private ObjectProvider<SpringBootScalarProperties> propertiesProvider;
+
+    @Mock
+    private ServerHttpRequest request;
+
+    private ScalarWebFluxController controller;
+
+    @BeforeEach
+    void setUp() {
+        lenient().when(propertiesProvider.getObject()).thenReturn(properties);
+        controller = new ScalarWebFluxController();
+        ReflectionTestUtils.setField(controller, "propertiesProvider", propertiesProvider);
+    }
+
+    @Nested
+    @DisplayName("GET /scalar endpoint")
+    class GetDocsEndpoint {
+
+        @Test
+        @DisplayName("should return HTML with default configuration")
+        void shouldReturnHtmlWithDefaultConfiguration() {
+            // Given
+            when(properties.getUrl()).thenReturn("https://registry.scalar.com/@scalar/apis/galaxy?format=json");
+            when(properties.getPageTitle()).thenReturn("Scalar API Reference");
+            when(properties.getPath()).thenReturn("/scalar");
+
+            // When
+            Mono<Resource> resourceMono = controller.getDocs(request);
+
+            // Then
+            StepVerifier.create(resourceMono)
+                    .assertNext(resource -> {
+                        assertThat(resource).isNotNull();
+                        assertThat(resource.exists()).isTrue();
+                        try {
+                            String html = new String(resource.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+                            assertThat(html)
+                                    .contains("<!doctype html>")
+                                    .contains("<title>Scalar API Reference</title>")
+                                    .contains("Scalar.createApiReference('#app',");
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+                    .verifyComplete();
+        }
+
+        @Test
+        @DisplayName("should return HTML with custom URL")
+        void shouldReturnHtmlWithCustomUrl() {
+            // Given
+            when(properties.getUrl()).thenReturn("https://example.com/api/openapi.json");
+            when(properties.getPageTitle()).thenReturn("Scalar API Reference");
+            when(properties.getPath()).thenReturn("/scalar");
+
+            // When
+            Mono<Resource> resourceMono = controller.getDocs(request);
+
+            // Then
+            StepVerifier.create(resourceMono)
+                    .assertNext(resource -> {
+                        assertThat(resource).isNotNull();
+                        assertThat(resource.exists()).isTrue();
+                        try {
+                            String html = new String(resource.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+                            assertThat(html)
+                                    .contains("<!doctype html>")
+                                    .contains("<title>Scalar API Reference</title>");
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+                    .verifyComplete();
+        }
+
+        @Test
+        @DisplayName("should return HTML with custom pageTitle")
+        void shouldReturnHtmlWithCustomPageTitle() {
+            // Given
+            when(properties.getPageTitle()).thenReturn("My Custom API Documentation");
+            when(properties.getPath()).thenReturn("/scalar");
+
+            // When
+            Mono<Resource> resourceMono = controller.getDocs(request);
+
+            // Then
+            StepVerifier.create(resourceMono)
+                    .assertNext(resource -> {
+                        assertThat(resource).isNotNull();
+                        assertThat(resource.exists()).isTrue();
+                        try {
+                            String html = new String(resource.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
+                            assertThat(html)
+                                    .contains("<title>My Custom API Documentation</title>");
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+                    .verifyComplete();
+        }
+    }
+
+    @Nested
+    @DisplayName("GET /scalar/scalar.js endpoint")
+    class GetScalarJsEndpoint {
+
+        @Test
+        @DisplayName("should return JavaScript file with correct content type")
+        void shouldReturnJavaScriptFileWithCorrectContentType() {
+            // When
+            Mono<Resource> resourceMono = controller.getScalarJs();
+
+            // Then
+            StepVerifier.create(resourceMono)
+                    .assertNext(resource -> {
+                        assertThat(resource).isNotNull();
+                        assertThat(resource.exists()).isTrue();
+                        try {
+                            byte[] content = resource.getInputStream().readAllBytes();
+                            assertThat(content)
+                                    .isNotNull()
+                                    .isNotEmpty();
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+                    .verifyComplete();
+        }
+    }
+}
+

package/scalar-webmvc/pom.xml

@@ -0,0 +1,103 @@
+<?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
+         http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>com.scalar.maven</groupId>
+    <artifactId>scalar-parent</artifactId>
+    <version>0.0.0</version>
+  </parent>
+
+  <artifactId>scalar-webmvc</artifactId>
+  <packaging>jar</packaging>
+
+  <name>Scalar API Reference Spring Boot WebMVC</name>
+  <description>Spring Boot WebMVC integration for Scalar API Reference</description>
+
+  <dependencies>
+    <!-- Core module -->
+    <dependency>
+      <groupId>com.scalar.maven</groupId>
+      <artifactId>scalar-core</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+
+    <!-- Spring Boot WebMVC -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+      <scope>provided</scope>
+    </dependency>
+
+    <!-- Spring Boot Auto-Configuration -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-autoconfigure</artifactId>
+      <scope>provided</scope>
+    </dependency>
+
+    <!-- Spring Boot Configuration Processor -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-configuration-processor</artifactId>
+      <optional>true</optional>
+    </dependency>
+
+    <!-- Spring Boot Actuator -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-actuator</artifactId>
+      <scope>provided</scope>
+    </dependency>
+
+    <!-- Test Dependencies -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-test</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>flatten-maven-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-gpg-plugin</artifactId>
+      </plugin>
+
+      <plugin>
+        <groupId>org.sonatype.central</groupId>
+        <artifactId>central-publishing-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
+</project>
+