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

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

@@ -1,21 +1,50 @@
 package com.vaadin.hilla;
 
+import javax.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 scheduling 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.
+     *
+     * @param action
+     *            the action to be scheduled or run immediately
+     */
+    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/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/EndpointCodeGenerator.java

@@ -17,21 +17,27 @@
 
 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 java.util.stream.Collectors;
 
+import com.vaadin.flow.server.VaadinContext;
+import com.vaadin.flow.server.frontend.FrontendTools;
+import com.vaadin.flow.server.frontend.FrontendUtils;
+import com.vaadin.flow.server.startup.ApplicationConfiguration;
 import com.vaadin.hilla.engine.EngineConfiguration;
 import com.vaadin.hilla.engine.GeneratorProcessor;
 import com.vaadin.hilla.engine.ParserProcessor;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.aop.framework.AopProxyUtils;
+import org.springframework.context.ApplicationContext;
 import org.springframework.stereotype.Component;
 
-import com.vaadin.flow.server.VaadinContext;
-import com.vaadin.flow.server.frontend.FrontendTools;
-import com.vaadin.flow.server.startup.ApplicationConfiguration;
-
 /**
  * Handles (re)generation of the TypeScript code.
  */
@@ -43,11 +49,10 @@ public class EndpointCodeGenerator {
 
     private final EndpointController endpointController;
     private final VaadinContext context;
-    private Path buildDirectory;
 
     private ApplicationConfiguration configuration;
-    private String nodeExecutable;
     private Set<String> classesUsedInOpenApi = null;
+    private EngineConfiguration engineConfiguration;
 
     /**
      * Creates the singleton.
@@ -74,71 +79,91 @@ 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 -> {
+            List<Class<?>> browserCallables = findBrowserCallables(
+                    engineConfiguration, applicationContext);
+            ParserProcessor parser = new ParserProcessor(engineConfiguration);
+            parser.process(browserCallables);
+
+            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);
+            }
+        });
+    }
+
+    /**
+     * Finds all beans in the application context that have a browser callable
+     * annotation.
+     *
+     * @param engineConfiguration
+     *            the engine configuration that provides the annotations to
+     *            search for
+     * @param applicationContext
+     *            the application context to search for beans in
+     * @return a list of classes that qualify as browser callables
+     */
+    public static List<Class<?>> findBrowserCallables(
+            EngineConfiguration engineConfiguration,
+            ApplicationContext applicationContext) {
+        return engineConfiguration.getEndpointAnnotations().stream()
+                .map(applicationContext::getBeansWithAnnotation)
+                .map(Map::values).flatMap(Collection::stream)
+                // maps to original class when proxies are found
+                // (also converts to class in all cases)
+                .map(AopProxyUtils::ultimateTargetClass).distinct()
+                .collect(Collectors.toList());
     }
 
     private void initIfNeeded() {
         if (configuration == null) {
             configuration = ApplicationConfiguration.get(context);
 
-            Path projectFolder = configuration.getProjectFolder().toPath();
-            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).withDefaultAnnotations()
+                    .nodeCommand(frontendTools.getNodeBinary()).build();
         }
     }
 
     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

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

@@ -3,7 +3,6 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.Optional;
 import java.util.Set;
@@ -13,7 +12,6 @@
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.vaadin.hilla.engine.EngineConfiguration;
-import com.vaadin.hilla.engine.ParserProcessor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -61,35 +59,10 @@ public static String getCurrentOpenAPI(Path buildDirectory,
      */
     public static Optional<Path> getCurrentOpenAPIPath(Path buildDirectory,
             boolean isProductionMode) throws IOException {
-        EngineConfiguration engineConfiguration = EngineConfiguration
-                .loadDirectory(buildDirectory);
-        if (engineConfiguration == null) {
-            return Optional.empty();
-        }
-        return Optional
-                .of(engineConfiguration.getOpenAPIFile(isProductionMode));
-    }
-
-    /**
-     * Generate a new openapi.json and return it, based on the classes in the
-     * build directory.
-     *
-     * @param buildDirectory
-     *            the build directory, {@code target} if running with Maven
-     * @param isProductionMode
-     *            whether to generate the openapi for production mode
-     * @return the contents of the generated openapi.json
-     * @throws IOException
-     *             if something went wrong
-     */
-    public static String generateOpenAPI(Path buildDirectory,
-            boolean isProductionMode) throws IOException {
-        EngineConfiguration engineConfiguration = EngineConfiguration
-                .loadDirectory(buildDirectory);
-        ParserProcessor parserProcessor = new ParserProcessor(
-                engineConfiguration, OpenAPIUtil.class.getClassLoader(),
-                isProductionMode);
-        return parserProcessor.createOpenAPI();
+        var engineConfiguration = new EngineConfiguration.Builder()
+                .buildDir(buildDirectory).productionMode(isProductionMode)
+                .withDefaultAnnotations().build();
+        return Optional.of(engineConfiguration.getOpenAPIFile());
     }
 
     /**