feat: add support for re-generating endpoints without restart

packages/java/endpoint/pom.xml

@@ -83,6 +83,11 @@
             <artifactId>spring-boot-autoconfigure</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <optional>true</optional>
+        </dependency>
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-commons</artifactId>

packages/java/endpoint/src/main/java/dev/hilla/EndpointControllerConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2022 Vaadin Ltd.
+ * Copyright 2000-2023 Vaadin Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of

packages/java/endpoint/src/main/java/dev/hilla/internal/hotswap/EndpointHotSwapListener.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2000-2023 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package dev.hilla.internal.hotswap;
+
+import com.vaadin.flow.internal.BrowserLiveReload;
+import dev.hilla.EndpointController;
+import dev.hilla.engine.EngineConfiguration;
+import dev.hilla.engine.GeneratorProcessor;
+import dev.hilla.engine.ParserProcessor;
+import jakarta.annotation.PostConstruct;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Optional;
+
+class EndpointHotSwapListener implements HotSwapListener {
+
+    private static final Logger LOGGER = LoggerFactory
+            .getLogger(EndpointHotSwapListener.class);
+
+    private final EndpointController endpointController;
+
+    private final EndpointHotSwapService endpointHotSwapService;
+
+    public EndpointHotSwapListener(EndpointController endpointController,
+            EndpointHotSwapService endpointHotSwapService) {
+        this.endpointController = endpointController;
+        this.endpointHotSwapService = endpointHotSwapService;
+    }
+
+    @PostConstruct
+    private void registerForHotSwapChanges() {
+        endpointHotSwapService.addHotSwapListener(this);
+    }
+
+    @Override
+    public void endpointChanged(EndpointChangedEvent event) {
+        EngineConfiguration engineConfiguration;
+        try {
+            engineConfiguration = EngineConfiguration
+                    .loadDirectory(event.buildDir());
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        ParserProcessor parser = new ParserProcessor(engineConfiguration,
+                this.getClass().getClassLoader());
+        parser.process();
+        GeneratorProcessor generator = new GeneratorProcessor(
+                engineConfiguration, "node");
+        generator.process();
+
+        this.endpointController.registerEndpoints();
+        reload(event.browserLiveReload());
+    }
+
+    private void reload(BrowserLiveReload browserLiveReload) {
+
+        Optional.ofNullable(browserLiveReload).ifPresent(liveReload -> {
+            LOGGER.debug("Reloading the browser after endpoint(s) changes...");
+            liveReload.reload();
+        });
+    }
+
+}

packages/java/endpoint/src/main/java/dev/hilla/internal/hotswap/EndpointHotSwapService.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2000-2023 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package dev.hilla.internal.hotswap;
+
+import com.vaadin.flow.internal.BrowserLiveReload;
+import com.vaadin.flow.shared.Registration;
+
+import java.nio.file.Path;
+
+/**
+ * The service interface that defines the API for EndpointHotSwapService
+ * implementations.
+ */
+public interface EndpointHotSwapService {
+
+    /**
+     * The method that starts the process for monitoring the changes in
+     * endpoints. The strategy for detecting the changes can be Polling,
+     * Watching the File System changes, etc. No matter what the strategy for
+     * detecting the changes is, instances of {@code EndpointChangedEvent}
+     * should be fired upon detecting changes in the endpoints and associated
+     * classes.
+     *
+     * @param buildDir
+     *            the path to project's build directory which is 'target' in
+     *            standard Maven projects and 'build' in standard Gradle
+     *            projects.
+     * @param browserLiveReload
+     *            the BrowserLiveReload object which is used to reload the
+     *            browser after any endpoint changes are detected.
+     *
+     * @see EndpointHotSwapService#addHotSwapListener(HotSwapListener)
+     */
+    void monitorChanges(Path buildDir, BrowserLiveReload browserLiveReload);
+
+    /**
+     * The method that enables registering {@code HotSwapListener}s to be
+     * notified whenever an {@code EndpointChangedEvent} is fired.
+     * 
+     * @param listener
+     *            an instance of HotSwapListener that implements the
+     *            {@code endpointChanged} method that will be called when an
+     *            {@code EndpointChangedEvent} is fired.
+     * @return the Listener Registration object that enables the cally to
+     *         deregister the listener.
+     */
+    Registration addHotSwapListener(HotSwapListener listener);
+}

packages/java/endpoint/src/main/java/dev/hilla/internal/hotswap/HotSwapConfiguration.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2000-2023 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package dev.hilla.internal.hotswap;
+
+import dev.hilla.EndpointController;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class HotSwapConfiguration {
+
+    @Bean
+    @ConfigurationProperties(prefix = "hilla.endpoint.hot-reload")
+    public HotSwapConfigurationProperties hotSwapConfigurationProperties() {
+        return new HotSwapConfigurationProperties();
+    }
+
+    @Bean
+    EndpointHotSwapService hotSwapWatchService(
+            @Autowired HotSwapConfigurationProperties configurationProperties) {
+        return new PollChangedEndpointsHotSwapService(
+                configurationProperties.getPollInterval());
+    }
+
+    @Bean
+    HotSwapServiceInitializer hotSwapServiceInitializer(
+            @Autowired EndpointHotSwapService endpointHotSwapService,
+            @Autowired HotSwapConfigurationProperties configurationProperties) {
+        return new HotSwapServiceInitializer(endpointHotSwapService,
+                configurationProperties.isEnabled());
+    }
+
+    @Bean
+    EndpointHotSwapListener endpointHotSwapListener(
+            @Autowired EndpointHotSwapService endpointHotSwapService,
+            @Autowired EndpointController endpointController) {
+        return new EndpointHotSwapListener(endpointController,
+                endpointHotSwapService);
+    }
+}

packages/java/endpoint/src/main/java/dev/hilla/internal/hotswap/HotSwapConfigurationProperties.java

@@ -0,0 +1,29 @@
+package dev.hilla.internal.hotswap;
+
+public class HotSwapConfigurationProperties {
+    /**
+     * Whether the endpoint changes hot-reload is enabled or not.
+     */
+    private boolean enabled = true;
+
+    /**
+     * The interval to poll for endpoint changes in seconds.
+     */
+    private int pollInterval = 5;
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public int getPollInterval() {
+        return pollInterval;
+    }
+
+    public void setPollInterval(int pollInterval) {
+        this.pollInterval = pollInterval;
+    }
+}

packages/java/endpoint/src/main/java/dev/hilla/internal/hotswap/HotSwapListener.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2000-2023 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package dev.hilla.internal.hotswap;
+
+import com.vaadin.flow.internal.BrowserLiveReload;
+
+import java.nio.file.Path;
+
+/**
+ * The interface that defines the contract for HotSwapListeners.
+ */
+public interface HotSwapListener {
+
+    /**
+     * The event object that is passed to {@code endpointChanged} method.
+     * @param buildDir
+     * @param browserLiveReload
+     */
+    record EndpointChangedEvent(Path buildDir, BrowserLiveReload browserLiveReload) {
+    }
+
+    /**
+     * The method that is called when an {@code EndpointChangedEvent} is fired.
+     */
+    void endpointChanged(EndpointChangedEvent event);
+
+}

packages/java/endpoint/src/main/java/dev/hilla/internal/hotswap/HotSwapServiceInitializer.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2000-2023 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package dev.hilla.internal.hotswap;
+
+import com.vaadin.flow.internal.BrowserLiveReload;
+import com.vaadin.flow.internal.BrowserLiveReloadAccessor;
+import com.vaadin.flow.server.ServiceInitEvent;
+import com.vaadin.flow.server.VaadinService;
+import com.vaadin.flow.server.VaadinServiceInitListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.Path;
+
+class HotSwapServiceInitializer implements VaadinServiceInitListener {
+
+    private final Logger LOGGER;
+
+    boolean endpointHotReloadEnabled;
+
+    private final EndpointHotSwapService endpointHotSwapService;
+
+    public HotSwapServiceInitializer(
+            EndpointHotSwapService endpointHotSwapService,
+            boolean endpointHotReloadEnabled) {
+        this.endpointHotSwapService = endpointHotSwapService;
+        this.endpointHotReloadEnabled = endpointHotReloadEnabled;
+        LOGGER = LoggerFactory.getLogger(this.getClass());
+    }
+
+    @Override
+    public void serviceInit(ServiceInitEvent serviceInitEvent) {
+        VaadinService vaadinService = serviceInitEvent.getSource();
+        BrowserLiveReloadAccessor.getLiveReloadFromService(vaadinService)
+                .ifPresent(browserLiveReload -> {
+                    if (BrowserLiveReload.Backend.SPRING_BOOT_DEVTOOLS != browserLiveReload
+                            .getBackend()
+                            && isDevModeLiveReloadEnabled(vaadinService)) {
+                        if (isEndpointHotReloadEnabled()) {
+                            endpointHotSwapService.monitorChanges(
+                                    getBuildDir(vaadinService),
+                                    browserLiveReload);
+                            info("Hilla Endpoint Hot-Reload service is enabled. "
+                                    + "You can disable it by defining the hilla.endpoint.hot-reload.enabled=false property in application.properties file.");
+                            info("The default polling interval for Hilla Endpoint Hot-Reload is 5 seconds. "
+                                    + "You can change the interval by defining a positive value for the hilla.endpoint.hot-reload.pollInterval property in application.properties file.");
+                        } else {
+                            info("Hilla Endpoint Hot-Reload service is disabled. "
+                                    + "You can enable it by removing the hilla.endpoint.hot-reload.enabled=true property from your application.properties file, "
+                                    + "or by setting its value to true.");
+                        }
+                    }
+                });
+    }
+
+    private boolean isDevModeLiveReloadEnabled(VaadinService vaadinService) {
+        return vaadinService.getDeploymentConfiguration()
+                .isDevModeLiveReloadEnabled();
+    }
+
+    private Path getBuildDir(VaadinService vaadinService) {
+        var deploymentConfig = vaadinService.getDeploymentConfiguration();
+        var projectFolder = deploymentConfig.getProjectFolder().toPath();
+        return projectFolder.resolve(deploymentConfig.getBuildFolder());
+    }
+
+    private boolean isEndpointHotReloadEnabled() {
+        return endpointHotReloadEnabled;
+    }
+
+    private void info(String message) {
+        LOGGER.info(message);
+    }
+}