generator-jhipster 8.7.1 → 8.7.3

package/dist/generators/spring-data-relational/files.js

@@ -66,6 +66,12 @@ export const sqlFiles = {
             templates: ['config/application-testprod.yml'],
         },
     ],
+    graalvm: [
+        javaMainPackageTemplatesBlock({
+            condition: ctx => !ctx.reactive && ctx.graalvmSupport,
+            templates: ['config/JacksonNativeConfiguration.java'],
+        }),
+    ],
 };
 export const h2Files = {
     serverResource: [

package/dist/generators/spring-data-relational/generator.d.ts

@@ -29,7 +29,8 @@ export default class SqlGenerator extends BaseApplicationGenerator {
         cleanupEntitiesTask: typeof cleanupEntitiesTask;
         writeEntitiesTask: (this: import("../index.js").GeneratorBaseCore, params: import("../../lib/types/application/tasks.js").TaskParamWithEntities<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>) => void;
     };
-    get postWriting(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").PostWritingTaskParam<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "addDependencies" | "addTestSpringFactory" | "addLog">;
+    get postWriting(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").PostWritingTaskParam<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "addDependencies" | "nativeHints" | "addTestSpringFactory" | "addLog" | "nativeGradleBuildTool">;
+    get postWritingEntities(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").PostWritingEntitiesTaskParam<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "jsonFilter">;
     /**
      * @private
      * Returns the JDBC URL for a databaseType

package/dist/generators/spring-data-relational/generator.js

@@ -25,7 +25,7 @@ import writeTask from './files.js';
 import cleanupTask from './cleanup.js';
 import writeEntitiesTask, { cleanupEntitiesTask } from './entity-files.js';
 import { getDBCExtraOption, getJdbcUrl, getR2dbcUrl } from './support/index.js';
-import { getDatabaseDriverForDatabase, getDatabaseTypeMavenDefinition, getH2MavenDefinition } from './internal/dependencies.js';
+import { getDatabaseDriverForDatabase, getDatabaseTypeMavenDefinition, getH2MavenDefinition, javaSqlDatabaseArtifacts, } from './internal/dependencies.js';
 const { SQL } = databaseTypes;
 export default class SqlGenerator extends BaseApplicationGenerator {
     async beforeQueue() {
@@ -132,7 +132,12 @@ export default class SqlGenerator extends BaseApplicationGenerator {
                 source.addJavaDefinitions?.({
                     condition: reactive,
                     dependencies: [
-                        { groupId: 'commons-beanutils', artifactId: 'commons-beanutils', version: javaDependencies['commons-beanutils'] },
+                        {
+                            groupId: 'commons-beanutils',
+                            artifactId: 'commons-beanutils',
+                            version: javaDependencies['commons-beanutils'],
+                            exclusions: [{ groupId: 'commons-logging', artifactId: 'commons-logging' }],
+                        },
                         { groupId: 'jakarta.persistence', artifactId: 'jakarta.persistence-api' },
                         { groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-data-r2dbc' },
                     ],
@@ -165,12 +170,68 @@ export default class SqlGenerator extends BaseApplicationGenerator {
                     condition: devDatabaseTypeH2Any && reactive,
                     mavenDefinition: h2Definitions?.r2dbc,
                 });
+                if (application.buildToolGradle) {
+                    const artifacts = javaSqlDatabaseArtifacts[prodDatabaseType];
+                    source.addJavaDefinition({ dependencies: [artifacts.jdbc, artifacts.testContainer, ...(reactive && artifacts.r2dbc ? [artifacts.r2dbc] : [])] }, { gradleFile: devDatabaseTypeH2Any ? 'gradle/profile_prod.gradle' : 'build.gradle' });
+                    if (devDatabaseTypeH2Any) {
+                        source.addJavaDefinition({ dependencies: [javaSqlDatabaseArtifacts.h2.jdbc, ...(reactive ? [javaSqlDatabaseArtifacts.h2.r2dbc] : [])] }, { gradleFile: 'gradle/profile_dev.gradle' });
+                    }
+                }
+            },
+            nativeHints({ application, source }) {
+                if (application.reactive || !application.graalvmSupport)
+                    return;
+                // Latest hibernate-core version supported by Reachability Repository is 6.5.0.Final
+                // Hints may be dropped if newer version is supported
+                // https://github.com/oracle/graalvm-reachability-metadata/blob/master/metadata/org.hibernate.orm/hibernate-core/index.json
+                source.addNativeHint({
+                    publicConstructors: ['org.hibernate.binder.internal.BatchSizeBinder.class'],
+                });
+            },
+            async nativeGradleBuildTool({ application, source }) {
+                if (!application.buildToolGradle || !application.graalvmSupport)
+                    return;
+                const { reactive, javaManagedProperties, buildToolMaven } = application;
+                if (buildToolMaven) {
+                    source.addMavenProperty({ property: 'spring.h2.console.enabled', value: 'true' });
+                }
+                if (!reactive) {
+                    source.addGradleDependencyCatalogVersion({ name: 'hibernate', version: javaManagedProperties['hibernate.version'] });
+                    source.addGradleDependencyCatalogPlugin({
+                        addToBuild: true,
+                        pluginName: 'hibernate',
+                        id: 'org.hibernate.orm',
+                        'version.ref': 'hibernate',
+                    });
+                }
             },
         });
     }
     get [BaseApplicationGenerator.POST_WRITING]() {
         return this.delegateTasksToBlueprint(() => this.postWriting);
     }
+    get postWritingEntities() {
+        return this.asPostWritingEntitiesTaskGroup({
+            async jsonFilter({ application, entities, source }) {
+                if (application.reactive || !application.graalvmSupport)
+                    return;
+                for (const entity of entities.filter(({ builtIn, builtInUser, embedded }) => builtInUser || (!builtIn && !embedded))) {
+                    source.editJavaFile(`${application.srcMainJava}/${entity.entityAbsoluteFolder}/domain/${entity.entityClass}.java`, {
+                        annotations: [
+                            {
+                                package: 'com.fasterxml.jackson.annotation',
+                                annotation: 'JsonFilter',
+                                parameters: () => '"lazyPropertyFilter"',
+                            },
+                        ],
+                    });
+                }
+            },
+        });
+    }
+    get [BaseApplicationGenerator.POST_WRITING_ENTITIES]() {
+        return this.delegateTasksToBlueprint(() => this.postWritingEntities);
+    }
     /**
      * @private
      * Returns the JDBC URL for a databaseType

package/dist/generators/spring-data-relational/internal/dependencies.d.ts

@@ -16,21 +16,101 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { JavaDependency } from '../../java/types.js';
 import type { MavenDefinition } from '../../maven/types.js';
 type DatabaseTypeDependencies = {
     jdbc: MavenDefinition;
     r2dbc: MavenDefinition;
 };
-type JavaDependency = {
-    groupId: string;
-    artifactId: string;
-    version?: string;
-};
 export type DatabaseArtifact = {
     jdbc: JavaDependency;
-    r2dbc: JavaDependency;
+    r2dbc?: JavaDependency;
+    testContainer?: JavaDependency;
+};
+export declare const javaSqlDatabaseArtifacts: {
+    readonly mariadb: {
+        readonly jdbc: {
+            readonly groupId: "org.mariadb.jdbc";
+            readonly artifactId: "mariadb-java-client";
+        };
+        readonly r2dbc: {
+            readonly groupId: "io.asyncer";
+            readonly artifactId: "r2dbc-mysql";
+        };
+        readonly testContainer: {
+            readonly groupId: "org.testcontainers";
+            readonly artifactId: "mariadb";
+            readonly scope: "test";
+        };
+    };
+    readonly mssql: {
+        readonly jdbc: {
+            readonly groupId: "com.microsoft.sqlserver";
+            readonly artifactId: "mssql-jdbc";
+        };
+        readonly r2dbc: {
+            readonly groupId: "io.r2dbc";
+            readonly artifactId: "r2dbc-mssql";
+        };
+        readonly testContainer: {
+            readonly groupId: "org.testcontainers";
+            readonly artifactId: "mssqlserver";
+            readonly scope: "test";
+        };
+    };
+    readonly mysql: {
+        readonly jdbc: {
+            readonly groupId: "com.mysql";
+            readonly artifactId: "mysql-connector-j";
+        };
+        readonly r2dbc: {
+            readonly groupId: "io.asyncer";
+            readonly artifactId: "r2dbc-mysql";
+        };
+        readonly testContainer: {
+            readonly groupId: "org.testcontainers";
+            readonly artifactId: "mysql";
+            readonly scope: "test";
+        };
+    };
+    readonly postgresql: {
+        readonly jdbc: {
+            readonly groupId: "org.postgresql";
+            readonly artifactId: "postgresql";
+        };
+        readonly r2dbc: {
+            readonly groupId: "org.postgresql";
+            readonly artifactId: "r2dbc-postgresql";
+        };
+        readonly testContainer: {
+            readonly groupId: "org.testcontainers";
+            readonly artifactId: "postgresql";
+            readonly scope: "test";
+        };
+    };
+    readonly oracle: {
+        readonly jdbc: {
+            readonly groupId: "com.oracle.database.jdbc";
+            readonly artifactId: "ojdbc8";
+        };
+        readonly testContainer: {
+            readonly groupId: "org.testcontainers";
+            readonly artifactId: "oracle-xe";
+            readonly scope: "test";
+        };
+    };
+    readonly h2: {
+        readonly jdbc: {
+            readonly groupId: "com.h2database";
+            readonly artifactId: "h2";
+        };
+        readonly r2dbc: {
+            readonly groupId: "io.r2dbc";
+            readonly artifactId: "r2dbc-h2";
+        };
+    };
 };
-export declare const getDatabaseDriverForDatabase: (databaseType: string) => DatabaseArtifact;
+export declare const getDatabaseDriverForDatabase: (databaseType: string) => any;
 export declare const getH2MavenDefinition: ({ prodDatabaseType, packageFolder, }: {
     prodDatabaseType: string;
     packageFolder: string;

package/dist/generators/spring-data-relational/internal/dependencies.js

@@ -22,27 +22,39 @@ const testcontainerFileForDB = {
     mysql: 'MysqlTestContainer.java',
     postgresql: 'PostgreSqlTestContainer.java',
 };
-const databaseArtifactForDB = {
+export const javaSqlDatabaseArtifacts = {
     mariadb: {
         jdbc: { groupId: 'org.mariadb.jdbc', artifactId: 'mariadb-java-client' },
         // maria-r2dbc driver is failing.
         // r2dbc: { groupId: 'org.mariadb', artifactId: 'r2dbc-mariadb' },
         r2dbc: { groupId: 'io.asyncer', artifactId: 'r2dbc-mysql' },
+        testContainer: { groupId: 'org.testcontainers', artifactId: 'mariadb', scope: 'test' },
     },
     mssql: {
         jdbc: { groupId: 'com.microsoft.sqlserver', artifactId: 'mssql-jdbc' },
         r2dbc: { groupId: 'io.r2dbc', artifactId: 'r2dbc-mssql' },
+        testContainer: { groupId: 'org.testcontainers', artifactId: 'mssqlserver', scope: 'test' },
     },
     mysql: {
         jdbc: { groupId: 'com.mysql', artifactId: 'mysql-connector-j' },
         r2dbc: { groupId: 'io.asyncer', artifactId: 'r2dbc-mysql' },
+        testContainer: { groupId: 'org.testcontainers', artifactId: 'mysql', scope: 'test' },
     },
     postgresql: {
         jdbc: { groupId: 'org.postgresql', artifactId: 'postgresql' },
         r2dbc: { groupId: 'org.postgresql', artifactId: 'r2dbc-postgresql' },
+        testContainer: { groupId: 'org.testcontainers', artifactId: 'postgresql', scope: 'test' },
+    },
+    oracle: {
+        jdbc: { groupId: 'com.oracle.database.jdbc', artifactId: 'ojdbc8' },
+        testContainer: { groupId: 'org.testcontainers', artifactId: 'oracle-xe', scope: 'test' },
+    },
+    h2: {
+        jdbc: { groupId: 'com.h2database', artifactId: 'h2' },
+        r2dbc: { groupId: 'io.r2dbc', artifactId: 'r2dbc-h2' },
     },
 };
-export const getDatabaseDriverForDatabase = (databaseType) => databaseArtifactForDB[databaseType];
+export const getDatabaseDriverForDatabase = (databaseType) => javaSqlDatabaseArtifacts[databaseType];
 export const getH2MavenDefinition = ({ prodDatabaseType, packageFolder, }) => {
     const testcontainerFile = testcontainerFileForDB[prodDatabaseType];
     const excludeContainerPlugin = testcontainerFile
@@ -63,11 +75,11 @@ export const getH2MavenDefinition = ({ prodDatabaseType, packageFolder, }) => {
         : [];
     return {
         jdbc: {
-            dependencies: [{ inProfile: 'dev', groupId: 'com.h2database', artifactId: 'h2' }],
+            dependencies: [{ inProfile: 'dev', ...javaSqlDatabaseArtifacts.h2.jdbc }],
             plugins: excludeContainerPlugin,
         },
         r2dbc: {
-            dependencies: [{ inProfile: 'dev', groupId: 'io.r2dbc', artifactId: 'r2dbc-h2' }],
+            dependencies: [{ inProfile: 'dev', ...javaSqlDatabaseArtifacts.h2.r2dbc }],
         },
     };
 };
@@ -76,41 +88,41 @@ export const getDatabaseTypeMavenDefinition = (databaseType, { inProfile }) => {
         mariadb: {
             jdbc: {
                 dependencies: [
-                    { inProfile, ...databaseArtifactForDB.mariadb.jdbc },
-                    { groupId: 'org.testcontainers', artifactId: 'mariadb', scope: 'test' },
+                    { inProfile, ...javaSqlDatabaseArtifacts.mariadb.jdbc },
+                    { inProfile, ...javaSqlDatabaseArtifacts.mariadb.testContainer },
                 ],
             },
             r2dbc: {
-                dependencies: [{ inProfile, ...databaseArtifactForDB.mariadb.r2dbc }],
+                dependencies: [{ inProfile, ...javaSqlDatabaseArtifacts.mariadb.r2dbc }],
             },
         },
         mssql: {
             jdbc: {
                 dependencies: [
-                    { inProfile, ...databaseArtifactForDB.mssql.jdbc },
-                    { groupId: 'org.testcontainers', artifactId: 'mssqlserver', scope: 'test' },
+                    { inProfile, ...javaSqlDatabaseArtifacts.mssql.jdbc },
+                    { inProfile, ...javaSqlDatabaseArtifacts.mssql.testContainer },
                 ],
             },
             r2dbc: {
-                dependencies: [{ inProfile, ...databaseArtifactForDB.mssql.r2dbc }],
+                dependencies: [{ inProfile, ...javaSqlDatabaseArtifacts.mssql.r2dbc }],
             },
         },
         mysql: {
             jdbc: {
                 dependencies: [
-                    { inProfile, ...databaseArtifactForDB.mysql.jdbc },
-                    { groupId: 'org.testcontainers', artifactId: 'mysql', scope: 'test' },
+                    { inProfile, ...javaSqlDatabaseArtifacts.mysql.jdbc },
+                    { inProfile, ...javaSqlDatabaseArtifacts.mysql.testContainer },
                 ],
             },
             r2dbc: {
-                dependencies: [{ inProfile, ...databaseArtifactForDB.mysql.r2dbc }],
+                dependencies: [{ inProfile, ...javaSqlDatabaseArtifacts.mysql.r2dbc }],
             },
         },
         oracle: {
             jdbc: {
                 dependencies: [
-                    { inProfile, groupId: 'com.oracle.database.jdbc', artifactId: 'ojdbc8' },
-                    { groupId: 'org.testcontainers', artifactId: 'oracle-xe', scope: 'test' },
+                    { inProfile, ...javaSqlDatabaseArtifacts.oracle.jdbc },
+                    { inProfile, ...javaSqlDatabaseArtifacts.oracle.testContainer },
                 ],
             },
             r2dbc: {},
@@ -118,12 +130,12 @@ export const getDatabaseTypeMavenDefinition = (databaseType, { inProfile }) => {
         postgresql: {
             jdbc: {
                 dependencies: [
-                    { inProfile, ...databaseArtifactForDB.postgresql.jdbc },
-                    { groupId: 'org.testcontainers', artifactId: 'postgresql', scope: 'test' },
+                    { inProfile, ...javaSqlDatabaseArtifacts.postgresql.jdbc },
+                    { inProfile, ...javaSqlDatabaseArtifacts.postgresql.testContainer },
                 ],
             },
             r2dbc: {
-                dependencies: [{ inProfile, ...databaseArtifactForDB.postgresql.r2dbc }],
+                dependencies: [{ inProfile, ...javaSqlDatabaseArtifacts.postgresql.r2dbc }],
             },
         },
     };

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/_entityPackage_/domain/_persistClass_.java.jhi.spring_data_persistable.ejs

@@ -36,7 +36,10 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 <&_ } -&>
 
 <&_ if (fragment.classAdditionalFieldsSection) { -&>
+    @org.springframework.data.annotation.Transient
+<%_ if (!reactive) { _%>
     @Transient
+<%_ } _%>
     private boolean isPersisted;
 <&_ } -&>
 
@@ -48,7 +51,10 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
     }
  <%_ } -%>
 
+    @org.springframework.data.annotation.Transient
+<%_ if (!reactive) { _%>
     @Transient
+<%_ } _%>
     @Override
     public boolean isNew() {
         return !this.isPersisted;

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/_entityPackage_/domain/_persistClass_.java.jhi.spring_data_reactive.ejs

@@ -22,7 +22,6 @@
 -%>
 <&_ if (fragment.importSection) { -&>
 import org.springframework.data.annotation.Id;
-import org.springframework.data.annotation.Transient;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 <&_ } -&>
@@ -55,7 +54,7 @@ import org.springframework.data.relational.core.mapping.Table;
 
 <%_ for (const relationship of relationships) { _%>
 <&_ if (fragment.relationship<%- relationship.relationshipNameCapitalized %>AnnotationSection) { -&>
-    @Transient
+    @org.springframework.data.annotation.Transient
 <&_ } -&>
 <%_ } -%>
 

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/config/DatabaseConfiguration.java.ejs

@@ -43,6 +43,10 @@ import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.elasticsearch.repository.config.Enable<% if (reactive) { %>Reactive<% } %>ElasticsearchRepositories;
 <%_ } _%>
 <%_ if (devDatabaseTypeH2Any) { _%>
+import java.sql.SQLException;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.boot.autoconfigure.h2.H2ConsoleProperties;
 import org.springframework.core.env.Environment;
 <%_ } _%>
 <%_ if (reactive) { _%>
@@ -64,9 +68,6 @@ import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 <%_ } _%>
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 
-<%_ if (devDatabaseTypeH2Any) { _%>
-import java.sql.SQLException;
-<%_ } _%>
 <%_ if (reactive) { _%>
 import java.time.Duration;
 import java.time.Instant;
@@ -94,6 +95,9 @@ import java.util.UUID;
 <%_ if (searchEngineElasticsearch) { _%>
 @Enable<% if (reactive) { %>Reactive<% } %>ElasticsearchRepositories("<%= packageName %>.repository.search")
 <%_ } _%>
+<%_ if (devDatabaseTypeH2Any) { _%>
+@EnableConfigurationProperties(H2ConsoleProperties.class)
+<%_ } _%>
 public class DatabaseConfiguration {
 
 <%_ if (devDatabaseTypeH2Any) { _%>
@@ -113,6 +117,7 @@ public class DatabaseConfiguration {
      */
     @Bean(initMethod = "start", destroyMethod = "stop")
     @Profile(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)
+    @ConditionalOnProperty(prefix = "spring.h2.console", name = "enabled", havingValue = "true")
     public Object h2TCPServer() throws SQLException {
         String port = getValidPortForH2();
         LOG.debug("H2 database is available on port {}", port);

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/config/JacksonNativeConfiguration.java.ejs

@@ -0,0 +1,98 @@
+package <%=packageName%>.config;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonObjectFormatVisitor;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
+import com.fasterxml.jackson.databind.ser.PropertyFilter;
+import com.fasterxml.jackson.databind.ser.PropertyWriter;
+import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
+import jakarta.persistence.Basic;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
+import java.lang.annotation.Annotation;
+import java.util.function.Function;
+import org.hibernate.Hibernate;
+import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class JacksonNativeConfiguration {
+
+    /*
+     * Filter to allow Jackson serializer to detect lazy-loaded properties when using hibernate-enhance-maven-plugin
+     * see: https://github.com/FasterXML/jackson-datatype-hibernate/issues/148#issuecomment-1383923857
+     */
+    @Bean
+    public Jackson2ObjectMapperBuilderCustomizer customizeJackson() {
+        return builder -> {
+            String filterName = "lazyPropertyFilter";
+            builder.filters(new SimpleFilterProvider().addFilter(filterName, new LazyPropertyFilter()));
+        };
+    }
+
+    <%- // Thanks to @hurelhuyag for contributing the LazyPropertyFilter source. %>
+    private class LazyPropertyFilter implements PropertyFilter {
+
+        public static boolean isPropertyInitialized(BeanPropertyWriter prop, Object bean) throws Exception {
+            return (
+                Hibernate.isPropertyInitialized(bean, prop.getName()) &&
+                isInitialized(prop, bean, ManyToOne.class, ManyToOne::fetch) &&
+                isInitialized(prop, bean, ElementCollection.class, ElementCollection::fetch) &&
+                isInitialized(prop, bean, OneToMany.class, OneToMany::fetch) &&
+                isInitialized(prop, bean, Basic.class, Basic::fetch)
+            );
+        }
+
+        public static <A extends Annotation> boolean isInitialized(
+            BeanPropertyWriter prop,
+            Object bean,
+            Class<A> type,
+            Function<A, FetchType> fetch
+        ) throws Exception {
+            var ann = prop.getAnnotation(type);
+            if (ann == null) {
+                return true;
+            }
+            var fetchType = fetch.apply(ann);
+            if (fetchType == FetchType.EAGER) {
+                return true;
+            }
+            var value = prop.get(bean);
+            return Hibernate.isInitialized(value);
+        }
+
+        @Override
+        public void serializeAsField(Object pojo, JsonGenerator gen, SerializerProvider prov, PropertyWriter writer) throws Exception {
+            var initialized = isPropertyInitialized((BeanPropertyWriter) writer, pojo);
+            if (initialized) {
+                writer.serializeAsField(pojo, gen, prov);
+            } else if (!gen.canOmitFields()) { // since 2.3
+                writer.serializeAsOmittedField(pojo, gen, prov);
+            }
+        }
+
+        @Override
+        public void serializeAsElement(Object elementValue, JsonGenerator gen, SerializerProvider prov, PropertyWriter writer) {
+            throw new RuntimeException("LazyPropertyFilter.serializeAsElement() currently unsupported");
+        }
+
+        @SuppressWarnings("deprecation")
+        @Override
+        public void depositSchemaProperty(PropertyWriter writer, ObjectNode propertiesNode, SerializerProvider provider)
+            throws JsonMappingException {
+            writer.depositSchemaProperty(propertiesNode, provider);
+        }
+
+        @Override
+        public void depositSchemaProperty(PropertyWriter writer, JsonObjectFormatVisitor objectVisitor, SerializerProvider provider)
+            throws JsonMappingException {
+            writer.depositSchemaProperty(objectVisitor, provider);
+        }
+    }
+}

package/dist/generators/vue/files-vue.js

@@ -37,13 +37,16 @@ export const vueFiles = {
     microfrontend: [
         clientRootTemplatesBlock({
             condition: generator => generator.microfrontend,
+            templates: ['module-federation.config.cjs'],
+        }),
+        clientRootTemplatesBlock({
+            condition: ctx => ctx.microfrontend && ctx.clientBundlerWebpack,
             templates: [
                 'webpack/config.js',
                 'webpack/webpack.common.js',
                 'webpack/webpack.dev.js',
                 'webpack/webpack.prod.js',
                 'webpack/vue.utils.js',
-                'webpack/webpack.microfrontend.js.jhi.vue',
             ],
         }),
         {

package/dist/generators/vue/generator.d.ts

@@ -6,7 +6,7 @@ export default class VueGenerator extends BaseApplicationGenerator {
     get default(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").TaskParamWithEntities<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "queueTranslateTransform">;
     get writing(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").WritingTaskParam<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "cleanup" | "cleanupOldFilesTask" | "writeEslintClientRootConfigFile" | "writeFiles">;
     get writingEntities(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").TaskParamWithEntities<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "cleanupEntitiesFiles" | "writeEntitiesFiles" | "writeEntityFiles">;
-    get postWriting(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").PostWritingTaskParam<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "addIndexAsset">;
+    get postWriting(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").PostWritingTaskParam<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "addMicrofrontendDependencies" | "addPackageJsonScripts" | "addIndexAsset">;
     get postWritingEntities(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").PostWritingEntitiesTaskParam<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "postWriteEntityFiles">;
     get end(): import("../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../lib/types/application/tasks.js").TaskParamWithApplication<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>, import("../../lib/types/application/application.js").ApplicationType<import("../base-application/index.js").Entity<import("../base-application/index.js").Field, never>>>, "end">;
     /**