feat!(generator): load endpoints from Spring components and stop using Maven/Gradle at each generation

packages/java/annotations/pom.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>com.vaadin</groupId>
+    <artifactId>hilla-project</artifactId>
+    <version>24.6-SNAPSHOT</version>
+    <relativePath>../../../pom.xml</relativePath>
+  </parent>
+
+  <artifactId>hilla-annotations</artifactId>
+  <packaging>jar</packaging>
+  <name>Hilla Annotations</name>
+
+  <properties>
+    <formatter.basedir>${project.parent.basedir}</formatter.basedir>
+  </properties>
+
+  <repositories>
+    <repository>
+      <id>vaadin-prereleases</id>
+      <url>
+        https://maven.vaadin.com/vaadin-prereleases/
+      </url>
+    </repository>
+  </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-core</artifactId>
+        </dependency>
+  </dependencies>
+</project>

packages/java/endpoint/src/main/java/com/vaadin/hilla/BrowserCallable.java → packages/java/annotations/src/main/java/com/vaadin/hilla/BrowserCallable.java

@@ -26,8 +26,8 @@
  * Makes the methods of the annotated class available to the browser.
  * <p>
  * For each class, a corresponding TypeScript class is generated in
- * {@code frontend/generated} with TypeScript methods for invoking the methods
- * in this class.
+ * {@code src/main/frontend/generated} with TypeScript methods for invoking the
+ * methods in this class.
  * <p>
  * This is an alias for {@link Endpoint}.
  */

packages/java/endpoint/src/main/java/com/vaadin/hilla/Endpoint.java → packages/java/annotations/src/main/java/com/vaadin/hilla/Endpoint.java

@@ -24,19 +24,16 @@
 
 /**
  * Annotation to mark the endpoints to be processed by
- * {@link EndpointController} class. Each class annotated automatically becomes
+ * {@code EndpointController} class. Each class annotated automatically becomes
  * a Spring {@link Component} bean.
  *
  * After the class is annotated and processed, it becomes available as a Vaadin
  * endpoint. This means that the class name and all its public methods can be
  * executed via the post call with the correct parameters sent in a request JSON
  * body. The methods' return values will be returned back as a response to the
- * calls. Refer to {@link EndpointController} for more details.
+ * calls. Refer to {@code EndpointController} for more details.
  * <p>
  * This is an alias for {@link BrowserCallable}.
- *
- * @see EndpointController
- * @see Component
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
@@ -48,7 +45,7 @@
      * <p>
      * Note: custom names are not allowed to be blank, be equal to any of the
      * ECMAScript reserved words or have whitespaces in them. See
-     * {@link EndpointNameChecker} for validation implementation details.
+     * {@code EndpointNameChecker} for validation implementation details.
      *
      * @return the name of the endpoint to use in post requests
      */

packages/java/endpoint/src/main/java/com/vaadin/hilla/ApplicationContextProvider.java

@@ -1,21 +1,45 @@
 package com.vaadin.hilla;
 
+import jakarta.annotation.Nonnull;
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.stereotype.Component;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
 @Component
 public class ApplicationContextProvider implements ApplicationContextAware {
     private static ApplicationContext applicationContext;
+    private static final List<Consumer<ApplicationContext>> pendingActions = new ArrayList<>();
 
     @Override
-    public void setApplicationContext(ApplicationContext applicationContext)
+    public void setApplicationContext(
+            @Nonnull ApplicationContext applicationContext)
             throws BeansException {
         ApplicationContextProvider.applicationContext = applicationContext;
+        pendingActions.forEach(action -> action.accept(applicationContext));
+        pendingActions.clear();
     }
 
     public static ApplicationContext getApplicationContext() {
         return applicationContext;
     }
+
+    // Allows to schedule actions that should be run when the application
+    // context is available, or to run them immediately if the context is
+    // already available and still active.
+    public static void runOnContext(Consumer<ApplicationContext> action) {
+        if (applicationContext == null
+                || (applicationContext instanceof ConfigurableApplicationContext
+                        && !((ConfigurableApplicationContext) applicationContext)
+                                .isActive())) {
+            pendingActions.add(action);
+        } else {
+            action.accept(applicationContext);
+        }
+    }
 }

packages/java/endpoint/src/main/java/com/vaadin/hilla/EndpointCodeGenerator.java

@@ -18,9 +18,13 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 
+import com.vaadin.flow.server.frontend.FrontendUtils;
 import com.vaadin.hilla.engine.EngineConfiguration;
 import com.vaadin.hilla.engine.GeneratorProcessor;
 import com.vaadin.hilla.engine.ParserProcessor;
@@ -46,8 +50,8 @@ public class EndpointCodeGenerator {
     private Path buildDirectory;
 
     private ApplicationConfiguration configuration;
-    private String nodeExecutable;
     private Set<String> classesUsedInOpenApi = null;
+    private EngineConfiguration engineConfiguration;
 
     /**
      * Creates the singleton.
@@ -74,37 +78,37 @@ public static EndpointCodeGenerator getInstance() {
     /**
      * Re-generates the endpoint TypeScript and re-registers the endpoints in
      * Java.
-     *
-     * @throws IOException
-     *             if something went wrong
      */
-    public void update() throws IOException {
+    public void update() {
         initIfNeeded();
         if (configuration.isProductionMode()) {
             throw new IllegalStateException(
                     "This method is not available in production mode");
         }
 
-        EngineConfiguration engineConfiguration = EngineConfiguration
-                .loadDirectory(buildDirectory);
-        ParserProcessor parser = new ParserProcessor(engineConfiguration,
-                getClass().getClassLoader(), false);
-        parser.process();
-        GeneratorProcessor generator = new GeneratorProcessor(
-                engineConfiguration, nodeExecutable, false);
-        generator.process();
-
-        OpenAPIUtil.getCurrentOpenAPIPath(buildDirectory, false)
-                .ifPresent(openApiPath -> {
-                    try {
-                        this.endpointController
-                                .registerEndpoints(openApiPath.toUri().toURL());
-                    } catch (IOException e) {
-                        LOGGER.error(
-                                "Endpoints could not be registered due to an exception: ",
-                                e);
-                    }
-                });
+        ApplicationContextProvider.runOnContext(applicationContext -> {
+            // TODO: extract this logic as it is also used in
+            // TaskGenerateOpenAPIImpl
+            List<Class<?>> endpoints = engineConfiguration.getParser()
+                    .getEndpointAnnotations().stream()
+                    .map(applicationContext::getBeansWithAnnotation)
+                    .map(Map::values).flatMap(Collection::stream)
+                    .<Class<?>> map(Object::getClass).distinct().toList();
+            ParserProcessor parser = new ParserProcessor(engineConfiguration);
+            parser.process(endpoints);
+
+            GeneratorProcessor generator = new GeneratorProcessor(
+                    engineConfiguration);
+            generator.process();
+
+            try {
+                var openApiPath = engineConfiguration.getOpenAPIFile();
+                this.endpointController
+                        .registerEndpoints(openApiPath.toUri().toURL());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
     }
 
     private void initIfNeeded() {
@@ -115,30 +119,36 @@ private void initIfNeeded() {
             buildDirectory = projectFolder
                     .resolve(configuration.getBuildFolder());
 
-            FrontendTools tools = new FrontendTools(configuration,
+            var frontendTools = new FrontendTools(configuration,
                     configuration.getProjectFolder());
-            nodeExecutable = tools.getNodeBinary();
+            engineConfiguration = new EngineConfiguration.Builder()
+                    .baseDir(configuration.getProjectFolder().toPath())
+                    .buildDir(configuration.getBuildFolder())
+                    .outputDir(
+                            FrontendUtils
+                                    .getFrontendGeneratedFolder(
+                                            configuration.getFrontendFolder())
+                                    .toPath())
+                    .productionMode(false)
+                    .nodeCommand(frontendTools.getNodeBinary()).create();
         }
     }
 
     public Optional<Set<String>> getClassesUsedInOpenApi() throws IOException {
         if (classesUsedInOpenApi == null) {
             initIfNeeded();
-            OpenAPIUtil.getCurrentOpenAPIPath(buildDirectory, false)
-                    .ifPresent(openApiPath -> {
-                        if (openApiPath.toFile().exists()) {
-                            try {
-                                classesUsedInOpenApi = OpenAPIUtil
-                                        .findOpenApiClasses(
-                                                Files.readString(openApiPath));
-                            } catch (IOException e) {
-                                throw new RuntimeException(e);
-                            }
-                        } else {
-                            LOGGER.debug(
-                                    "No OpenAPI file is available yet ...");
-                        }
-                    });
+            var conf = EngineConfiguration.getDefault();
+            var openApiPath = conf.getOpenAPIFile();
+            if (openApiPath != null && openApiPath.toFile().exists()) {
+                try {
+                    classesUsedInOpenApi = OpenAPIUtil
+                            .findOpenApiClasses(Files.readString(openApiPath));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            } else {
+                LOGGER.debug("No OpenAPI file is available yet ...");
+            }
         }
         return Optional.ofNullable(classesUsedInOpenApi);
     }

packages/java/endpoint/src/main/java/com/vaadin/hilla/EndpointController.java

@@ -17,16 +17,10 @@
 
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
-import java.io.IOException;
 import java.net.URL;
-import java.util.Map;
-import java.util.Optional;
 import java.util.TreeMap;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -130,10 +124,6 @@ public void registerEndpoints(URL openApiResource) {
         endpointBeans
                 .putAll(context.getBeansWithAnnotation(BrowserCallable.class));
 
-        // By default, only register those endpoints included in the Hilla
-        // OpenAPI definition file
-        registerEndpointsFromApiDefinition(endpointBeans, openApiResource);
-
         if (endpointRegistry.isEmpty() && !endpointBeans.isEmpty()) {
             LOGGER.debug("No endpoints found in openapi.json:"
                     + " registering all endpoints found using the Spring context");
@@ -310,46 +300,6 @@ private ResponseEntity<String> buildEnforcementResponseEntity(
         }
     }
 
-    /**
-     * Parses the <code>openapi.json</code> file to discover defined endpoints.
-     *
-     * @param knownEndpointBeans
-     *            the endpoint beans found in the Spring context
-     */
-    private void registerEndpointsFromApiDefinition(
-            Map<String, Object> knownEndpointBeans, URL openApiResource) {
-
-        if (openApiResource == null) {
-            LOGGER.debug(
-                    "Resource 'hilla-openapi.json' is not available: endpoints cannot be registered yet");
-        } else {
-            try (var stream = openApiResource.openStream()) {
-                // Read the openapi.json file and extract the tags, which in
-                // turn define the endpoints and their implementation classes
-                var rootNode = new ObjectMapper().readTree(stream);
-                var tagsNode = (ArrayNode) rootNode.get("tags");
-
-                if (tagsNode != null) {
-                    // Declared endpoints are first searched as Spring Beans. If
-                    // not found, they are, if possible, instantiated as regular
-                    // classes using their default constructor
-                    tagsNode.forEach(tag -> {
-                        Optional.ofNullable(tag.get("name"))
-                                .map(JsonNode::asText)
-                                .map(knownEndpointBeans::get)
-                                .or(() -> Optional
-                                        .ofNullable(tag.get("x-class-name"))
-                                        .map(JsonNode::asText)
-                                        .map(this::instantiateEndpointByClassName))
-                                .ifPresent(endpointRegistry::registerEndpoint);
-                    });
-                }
-            } catch (IOException e) {
-                LOGGER.warn("Failed to read openapi.json", e);
-            }
-        }
-    }
-
     /**
      * Instantiates an endpoint by its class name. Nothing special here, the
      * main purpose is to allow to instantiate in a lambda expression and log