generator-jhipster 8.7.1 → 8.7.3

package/dist/generators/gradle/templates/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

package/dist/generators/gradle/types.d.ts

@@ -6,9 +6,10 @@ export type GradleScript = { script: string };
 
 export type GradleLibraryDependency = { libraryName: string; scope?: string };
 
-export type GradleDependency =
+export type GradleDependency = (
   | { groupId: string; artifactId: string; version?: string; scope: string; classifier?: string }
-  | Required<GradleLibraryDependency>;
+  | Required<GradleLibraryDependency>
+) & { closure?: string[] };
 
 export type GradlePlugin = { id: string; version?: string };
 

package/dist/generators/init/command.d.ts

@@ -1,21 +1,5 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * 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
- *
- *      https://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.
- */
-import type { JHipsterCommandDefinition } from '../../lib/command/index.js';
-declare const command: JHipsterCommandDefinition;
+declare const command: {
+    readonly options: {};
+    readonly import: readonly ["jhipster:git", "project-name", "jhipster:javascript:prettier", "jhipster:javascript:husky"];
+};
 export default command;

package/dist/generators/init/command.js

@@ -1,6 +1,6 @@
 import { GENERATOR_PROJECT_NAME } from '../generator-list.js';
 const command = {
     options: {},
-    import: [GENERATOR_PROJECT_NAME, 'jhipster:javascript:prettier', 'jhipster:javascript:husky'],
+    import: ['jhipster:git', GENERATOR_PROJECT_NAME, 'jhipster:javascript:prettier', 'jhipster:javascript:husky'],
 };
 export default command;

package/dist/generators/init/resources/.node-version

@@ -1 +1 @@
-20.17.0
+22.11.0

package/dist/generators/java/command.d.ts

@@ -1,7 +1,5 @@
 declare const command: {
-    options: {};
-    import: string[];
+    readonly options: {};
+    readonly import: readonly ["jhipster:java:bootstrap", "jhipster:java:domain", "jhipster:java:build-tool"];
 };
-export type Coomand = typeof command;
-declare const _default: import("../index.js").JHipsterCommandDefinition;
-export default _default;
+export default command;

package/dist/generators/java/command.js

@@ -1,24 +1,5 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * 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
- *
- *      https://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.
- */
-import { asCommand } from '../type-utils.js';
 const command = {
     options: {},
     import: ['jhipster:java:bootstrap', 'jhipster:java:domain', 'jhipster:java:build-tool'],
 };
-export default asCommand(command);
+export default command;

package/dist/generators/java/generators/bootstrap/command.d.ts

@@ -41,6 +41,13 @@ declare const command: {
             readonly scope: "storage";
             readonly description: "The package name for the generated application";
         };
+        readonly packageFolder: {
+            readonly cli: {
+                readonly type: StringConstructor;
+                readonly hide: true;
+            };
+            readonly scope: "storage";
+        };
     };
     readonly import: readonly [];
 };

package/dist/generators/java/generators/bootstrap/command.js

@@ -29,6 +29,13 @@ const command = {
             scope: 'storage',
             description: 'The package name for the generated application',
         },
+        packageFolder: {
+            cli: {
+                type: String,
+                hide: true,
+            },
+            scope: 'storage',
+        },
     },
     import: [],
 };

package/dist/generators/java/generators/build-tool/generator.js

@@ -54,38 +54,62 @@ export default class BuildToolGenerator extends BaseApplicationGenerator {
             prepareJavaApplication({ application, source }) {
                 source.addJavaDependencies = (dependencies, options) => {
                     if (application.buildToolMaven) {
-                        const annotationProcessors = dependencies.filter(dep => dep.scope === 'annotationProcessor');
-                        const importDependencies = dependencies.filter(dep => dep.scope === 'import');
-                        const commonDependencies = dependencies.filter(dep => !['annotationProcessor', 'import'].includes(dep.scope));
-                        const convertVersionToRef = ({ version, versionRef, ...artifact }) => version || versionRef ? { ...artifact, version: `\${${versionRef ?? artifact.artifactId}.version}` } : artifact;
+                        const convertVersionToMavenDependency = ({ versionRef, version, exclusions, ...artifact }) => {
+                            // If a version is provided, convert to version ref using artifactId
+                            versionRef ??= version ? artifact.artifactId : undefined;
+                            version = versionRef ? `\${${versionRef}.version}` : undefined;
+                            const additionalContent = exclusions?.length
+                                ? `<exclusions>${exclusions.map(e => `
+                <exclusion>
+                    <groupId>${e.groupId}</groupId>
+                    <artifactId>${e.artifactId}</artifactId>
+                </exclusion>`)}
+                </exclusions>`
+                                : '';
+                            return additionalContent ? { ...artifact, version, additionalContent } : { ...artifact, version };
+                        };
                         const removeScope = ({ scope: _scope, ...artifact }) => artifact;
+                        const properties = dependencies
+                            .filter(dep => dep.version)
+                            .map(({ artifactId, version }) => ({ property: `${artifactId}.version`, value: version }));
+                        const annotationProcessors = dependencies
+                            .filter(dep => dep.scope === 'annotationProcessor')
+                            .map(removeScope)
+                            .map(convertVersionToMavenDependency);
+                        const dependencyManagement = dependencies.filter(dep => dep.scope === 'import').map(convertVersionToMavenDependency);
+                        const commonDependencies = dependencies
+                            .filter(dep => !['annotationProcessor', 'import'].includes(dep.scope))
+                            .map(convertVersionToMavenDependency);
                         source.addMavenDefinition?.({
-                            properties: dependencies
-                                .filter(dep => dep.version)
-                                .map(({ artifactId, version }) => ({ property: `${artifactId}.version`, value: version })),
+                            properties,
                             dependencies: [
-                                ...commonDependencies.map(convertVersionToRef),
+                                ...commonDependencies,
                                 // Add a provided scope for annotation processors so that version is not required in annotationProcessor dependencies
                                 ...annotationProcessors.filter(dep => !dep.version).map(artifact => ({ ...artifact, scope: 'provided' })),
                             ],
-                            dependencyManagement: importDependencies.map(convertVersionToRef),
-                            annotationProcessors: annotationProcessors.map(convertVersionToRef).map(removeScope),
+                            dependencyManagement,
+                            annotationProcessors,
                         });
                     }
                     if (application.buildToolGradle) {
-                        source.addGradleDependencies?.(dependencies
+                        const gradleDependencies = dependencies.map(({ exclusions, ...dep }) => ({
+                            ...dep,
+                            closure: exclusions?.map(({ groupId, artifactId }) => `    exclude group: '${groupId}', module: '${artifactId}'`),
+                        }));
+                        source.addGradleDependencies?.(gradleDependencies
                             .filter(dep => !dep.version && !dep.versionRef)
                             .map(({ scope, type, ...artifact }) => ({
                             ...artifact,
                             scope: javaScopeToGradleScope({ scope, type }),
                         })), options);
-                        source.addGradleDependencyCatalogLibraries?.(dependencies
+                        source.addGradleDependencyCatalogLibraries?.(gradleDependencies
                             .filter(dep => dep.version || dep.versionRef)
-                            .map(({ scope, type, groupId, artifactId, version, versionRef }) => {
+                            .map(({ scope, type, groupId, artifactId, version, versionRef, closure }) => {
                             const library = {
                                 libraryName: artifactId,
                                 module: `${groupId}:${artifactId}`,
                                 scope: javaScopeToGradleScope({ scope, type }),
+                                closure,
                             };
                             return version ? { ...library, version } : { ...library, 'version.ref': versionRef };
                         }), options);

package/dist/generators/java/generators/graalvm/command.d.ts

@@ -0,0 +1,5 @@
+declare const command: {
+    readonly configs: {};
+    readonly import: readonly [];
+};
+export default command;

package/dist/generators/java/generators/graalvm/command.js

@@ -0,0 +1,5 @@
+const command = {
+    configs: {},
+    import: [],
+};
+export default command;

package/dist/generators/java/generators/graalvm/generator.d.ts

@@ -0,0 +1,9 @@
+import BaseApplicationGenerator from '../../../base-application/index.js';
+export default class GraalvmGenerator extends BaseApplicationGenerator {
+    beforeQueue(): Promise<void>;
+    get initializing(): import("../../../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../../../lib/types/base/tasks.js").TaskParamWithControl, "forceConfig">;
+    get preparing(): import("../../../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../../../lib/types/application/tasks.js").PreparingTaskParam<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>>>, "load" | "addNativeHint" | "packageJson">;
+    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>>>, "disabledInAotModeAnnotation">;
+    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>>>, "writingTemplateTask">;
+    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>>>, "customizeGradle" | "customizeMaven" | "springBootHintsConfiguration" | "springBootRestErrors" | "springBootTechnicalStructureTest" | "nativeHints">;
+}

package/dist/generators/java/generators/graalvm/generator.js

@@ -0,0 +1,222 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+import { extname } from 'path';
+import { isFileStateDeleted, isFileStateModified } from 'mem-fs-editor/state';
+import { passthrough } from '@yeoman/transform';
+import BaseApplicationGenerator from '../../../base-application/index.js';
+import { createNeedleCallback } from '../../../base/support/needles.js';
+import { addJavaAnnotation, addJavaImport } from '../../../java/support/add-java-annotation.js';
+import { javaMainPackageTemplatesBlock } from '../../../java/support/files.js';
+import { mavenDefinition } from './internal/maven-definition.js';
+export default class GraalvmGenerator extends BaseApplicationGenerator {
+    async beforeQueue() {
+        if (!this.fromBlueprint) {
+            await this.composeWithBlueprints();
+        }
+        if (!this.delegateToBlueprint) {
+            await this.dependsOnBootstrapApplication();
+        }
+    }
+    get initializing() {
+        return this.asInitializingTaskGroup({
+            forceConfig() {
+                // Cache is not supported for GraalVM native image
+                this.jhipsterConfig.cacheProvider ??= 'no';
+            },
+        });
+    }
+    get [BaseApplicationGenerator.INITIALIZING]() {
+        return this.delegateTasksToBlueprint(() => this.initializing);
+    }
+    get preparing() {
+        return this.asPreparingTaskGroup({
+            load({ application }) {
+                this.loadJavaDependenciesFromGradleCatalog(application.javaDependencies);
+            },
+            addNativeHint({ source, application }) {
+                source.addNativeHint = ({ advanced = [], declaredConstructors = [], publicConstructors = [], resources = [] }) => {
+                    this.editFile(`${application.javaPackageSrcDir}config/NativeConfiguration.java`, addJavaImport('org.springframework.aot.hint.MemberCategory'), createNeedleCallback({
+                        contentToAdd: [
+                            ...advanced,
+                            ...resources.map(resource => `hints.resources().registerPattern("${resource}");`),
+                            ...publicConstructors.map(classPath => `hints.reflection().registerType(${classPath}, (hint) -> hint.withMembers(MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS));`),
+                            ...declaredConstructors.map(classPath => `hints.reflection().registerType(${classPath}, (hint) -> hint.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS));`),
+                        ],
+                        needle: 'add-native-hints',
+                        ignoreWhitespaces: true,
+                    }));
+                };
+            },
+            async packageJson({ application }) {
+                const { buildToolGradle, packageJsonScripts } = application;
+                const scripts = buildToolGradle
+                    ? {
+                        'native-package': './gradlew nativeCompile -Pnative -Pprod -x test -x integrationTest',
+                        'native-package-dev': './gradlew nativeCompile -Pnative -Pdev -x test -x integrationTest',
+                        'native-start': './build/native/nativeCompile/native-executable',
+                    }
+                    : {
+                        'native-package': './mvnw package -B -ntp -Pnative,prod -DskipTests',
+                        'native-package-dev': './mvnw package -B -ntp -Pnative,dev,webapp -DskipTests',
+                        'native-start': './target/native-executable',
+                    };
+                Object.assign(packageJsonScripts, {
+                    'native-e2e': 'concurrently -k -s first -n application,e2e -c red,blue npm:native-start npm:e2e:headless',
+                    ...scripts,
+                });
+            },
+        });
+    }
+    get [BaseApplicationGenerator.PREPARING]() {
+        return this.delegateTasksToBlueprint(() => this.preparing);
+    }
+    get default() {
+        return this.asDefaultTaskGroup({
+            // workaround for https://github.com/spring-projects/spring-boot/issues/32195
+            async disabledInAotModeAnnotation({ application }) {
+                this.queueTransformStream({
+                    name: 'adding @DisabledInAotMode annotations',
+                    filter: file => !isFileStateDeleted(file) &&
+                        isFileStateModified(file) &&
+                        file.path.startsWith(this.destinationPath(application.srcTestJava)) &&
+                        extname(file.path) === '.java',
+                    refresh: false,
+                }, passthrough(file => {
+                    const contents = file.contents.toString('utf8');
+                    if (/@(MockBean|SpyBean)/.test(contents) || (application.reactive && /@AuthenticationIntegrationTest/.test(contents))) {
+                        file.contents = Buffer.from(addJavaAnnotation(contents, { package: 'org.springframework.test.context.aot', annotation: 'DisabledInAotMode' }));
+                    }
+                }));
+            },
+        });
+    }
+    get [BaseApplicationGenerator.DEFAULT]() {
+        return this.delegateTasksToBlueprint(() => this.default);
+    }
+    get writing() {
+        return this.asWritingTaskGroup({
+            async writingTemplateTask({ application }) {
+                await this.writeFiles({
+                    sections: {
+                        common: [{ templates: ['README.md.jhi.native'] }],
+                        config: [
+                            javaMainPackageTemplatesBlock({
+                                templates: ['config/NativeConfiguration.java'],
+                            }),
+                        ],
+                        gradle: [
+                            {
+                                condition: ctx => ctx.buildToolGradle,
+                                templates: ['gradle/native.gradle'],
+                            },
+                        ],
+                    },
+                    context: application,
+                });
+            },
+        });
+    }
+    get [BaseApplicationGenerator.WRITING]() {
+        return this.delegateTasksToBlueprint(() => this.writing);
+    }
+    get postWriting() {
+        return this.asPostWritingTaskGroup({
+            async customizeGradle({ application, source }) {
+                const { buildToolGradle, javaDependencies } = application;
+                if (!buildToolGradle)
+                    return;
+                source.addGradleDependencyCatalogPlugin({
+                    addToBuild: true,
+                    pluginName: 'graalvm',
+                    id: 'org.graalvm.buildtools.native',
+                    version: javaDependencies.nativeBuildTools,
+                });
+                source.applyFromGradle({ script: 'gradle/native.gradle' });
+            },
+            async customizeMaven({ application, source }) {
+                const { buildToolMaven, reactive, databaseTypeSql, javaDependencies, nativeLanguageDefinition, languagesDefinition } = application;
+                if (!buildToolMaven)
+                    return;
+                source.addMavenDefinition(mavenDefinition({
+                    reactive,
+                    nativeBuildToolsVersion: javaDependencies.nativeBuildTools,
+                    databaseTypeSql,
+                    userLanguage: nativeLanguageDefinition.languageTag,
+                    languages: languagesDefinition.map(def => def.languageTag),
+                }));
+            },
+            springBootHintsConfiguration({ application, source }) {
+                const { mainClass, javaPackageSrcDir, packageName, backendTypeSpringBoot } = application;
+                if (backendTypeSpringBoot) {
+                    source.editJavaFile(`${javaPackageSrcDir}${mainClass}.java`, {
+                        annotations: [
+                            {
+                                package: 'org.springframework.context.annotation',
+                                annotation: 'ImportRuntimeHints',
+                                parameters: () => `{ ${packageName}.config.NativeConfiguration.JHipsterNativeRuntimeHints.class }`,
+                            },
+                        ],
+                    });
+                }
+            },
+            springBootRestErrors({ application, source }) {
+                const { javaPackageSrcDir, backendTypeSpringBoot } = application;
+                if (backendTypeSpringBoot) {
+                    source.editJavaFile(`${javaPackageSrcDir}/web/rest/errors/FieldErrorVM.java`, {
+                        annotations: [
+                            {
+                                package: 'org.springframework.aot.hint.annotation',
+                                annotation: 'RegisterReflectionForBinding',
+                                parameters: () => '{ FieldErrorVM.class }',
+                            },
+                        ],
+                    });
+                }
+            },
+            // workaround for arch error in backend:unit:test caused by gradle's org.graalvm.buildtools.native plugin
+            springBootTechnicalStructureTest({ application, source }) {
+                const { buildToolGradle, javaPackageTestDir, backendTypeSpringBoot } = application;
+                if (!buildToolGradle || !backendTypeSpringBoot)
+                    return;
+                source.editJavaFile(`${javaPackageTestDir}/TechnicalStructureTest.java`, {
+                    staticImports: ['com.tngtech.archunit.core.domain.JavaClass.Predicates.simpleNameEndingWith'],
+                }, contents => contents.includes('__BeanFactoryRegistrations')
+                    ? contents
+                    : contents.replace('.ignoreDependency(belongToAnyOf', `.ignoreDependency(simpleNameEndingWith("_BeanFactoryRegistrations"), alwaysTrue())
+    .ignoreDependency(belongToAnyOf`));
+            },
+            nativeHints({ source, application }) {
+                if (!application.backendTypeSpringBoot)
+                    return;
+                source.addNativeHint({
+                    advanced: [
+                        // Undertow
+                        'hints.reflection().registerType(sun.misc.Unsafe.class, (hint) -> hint.withMembers(MemberCategory.INVOKE_PUBLIC_METHODS));',
+                        // Thymeleaf template
+                        'hints.reflection().registerType(java.util.Locale.class, (hint) -> hint.withMembers(MemberCategory.INVOKE_PUBLIC_METHODS));',
+                    ],
+                    resources: ['i18n/*'],
+                });
+            },
+        });
+    }
+    get [BaseApplicationGenerator.POST_WRITING]() {
+        return this.delegateTasksToBlueprint(() => this.postWriting);
+    }
+}

package/dist/generators/java/generators/graalvm/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+export { default } from './generator.js';
+export { default as command } from './command.js';

package/dist/generators/java/generators/graalvm/index.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+export { default } from './generator.js';
+export { default as command } from './command.js';

package/dist/generators/java/generators/graalvm/internal/maven-definition.d.ts

@@ -0,0 +1,8 @@
+import type { MavenDefinition } from '../../../../maven/types.js';
+export declare const mavenDefinition: ({ reactive, nativeBuildToolsVersion, databaseTypeSql, userLanguage, languages, }: {
+    reactive?: boolean;
+    nativeBuildToolsVersion?: string;
+    databaseTypeSql?: boolean;
+    userLanguage: string;
+    languages: string[];
+}) => MavenDefinition;

package/dist/generators/java/generators/graalvm/internal/maven-definition.js

@@ -0,0 +1,130 @@
+export const mavenDefinition = ({ reactive, nativeBuildToolsVersion, databaseTypeSql, userLanguage, languages, }) => ({
+    properties: [
+        { property: 'repackage.classifier' },
+        { property: 'native-image-name', value: 'native-executable' },
+        { property: 'native-buildtools.version', value: nativeBuildToolsVersion },
+    ],
+    pluginManagement: [
+        {
+            groupId: 'org.graalvm.buildtools',
+            artifactId: 'native-maven-plugin',
+            version: '${native-buildtools.version}',
+            additionalContent: `
+        <configuration>
+            <fallback>false</fallback>
+            <classesDirectory>\${project.build.outputDirectory}</classesDirectory>
+            <metadataRepository>
+                <enabled>true</enabled>
+            </metadataRepository>
+            <imageName>\${native-image-name}</imageName>
+            <verbose>true</verbose>
+            <buildArgs>
+                <buildArg>-Duser.language=${userLanguage}</buildArg>
+                <buildArg>-H:IncludeLocales=${languages.join(',')}</buildArg>
+            </buildArgs>
+            <jvmArgs>
+                <arg>-Xms4g</arg>
+                <arg>-Xmx10g</arg>
+            </jvmArgs>
+        </configuration>`,
+        },
+        ...(reactive || !databaseTypeSql
+            ? []
+            : [
+                {
+                    groupId: 'org.hibernate.orm.tooling',
+                    artifactId: 'hibernate-enhance-maven-plugin',
+                    version: '${hibernate.version}',
+                    additionalContent: `
+                <configuration>
+                    <enableLazyInitialization>true</enableLazyInitialization>
+                </configuration>`,
+                },
+            ]),
+    ],
+    profiles: [
+        {
+            id: 'native',
+            content: `
+        <properties>
+            <repackage.classifier>exec</repackage.classifier>
+            <modernizer.skip>true</modernizer.skip>
+            <spring.h2.console.enabled>false</spring.h2.console.enabled>
+        </properties>
+        <build>
+            <plugins>${databaseTypeSql && !reactive
+                ? `
+                <plugin>
+                    <groupId>org.hibernate.orm.tooling</groupId>
+                    <artifactId>hibernate-enhance-maven-plugin</artifactId>
+                    <executions>
+                        <execution>
+                            <goals>
+                                <goal>enhance</goal>
+                            </goals>
+                        </execution>
+                    </executions>
+                </plugin>`
+                : ``}
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-jar-plugin</artifactId>
+                    <configuration>
+                        <archive>
+                            <manifestEntries>
+                                <Spring-Boot-Native-Processed>true</Spring-Boot-Native-Processed>
+                            </manifestEntries>
+                        </archive>
+                    </configuration>
+                </plugin>
+                <plugin>
+                    <groupId>org.springframework.boot</groupId>
+                    <artifactId>spring-boot-maven-plugin</artifactId>
+                    <configuration>
+                        <image>
+                            <builder>paketobuildpacks/builder:tiny</builder>
+                            <env>
+                                <BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE>
+                            </env>
+                        </image>
+                    </configuration>
+                    <executions>
+                        <execution>
+                            <id>process-aot</id>
+                            <goals>
+                                <goal>process-aot</goal>
+                            </goals>
+                        </execution>
+                    </executions>
+                </plugin>
+                <plugin>
+                    <groupId>org.graalvm.buildtools</groupId>
+                    <artifactId>native-maven-plugin</artifactId>
+                    <executions>
+                        <execution>
+                            <id>add-reachability-metadata</id>
+                            <goals>
+                                <goal>add-reachability-metadata</goal>
+                            </goals>
+                        </execution>
+                        <execution>
+                            <id>build-native</id>
+                            <goals>
+                                <goal>compile-no-fork</goal>
+                            </goals>
+                            <phase>package</phase>
+                        </execution>
+                        <execution>
+                            <id>test-native</id>
+                            <goals>
+                                <goal>test</goal>
+                            </goals>
+                            <phase>test</phase>
+                        </execution>
+                    </executions>
+                </plugin>
+            </plugins>
+        </build>`,
+        },
+    ],
+});

package/dist/generators/java/generators/graalvm/resources/build.gradle

@@ -0,0 +1 @@
+// required by dependabot