generator-jhipster 8.7.1 → 8.7.2

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

package/dist/generators/java/generators/graalvm/resources/gradle/libs.versions.toml

@@ -0,0 +1,5 @@
+[versions]
+nativeBuildTools = '0.10.3'
+
+[libraries]
+nativeGradlePlugin = { module = 'org.graalvm.buildtools:native-gradle-plugin', version.ref = 'nativeBuildTools' }

package/dist/generators/java/generators/graalvm/templates/README.md.jhi.native.ejs

@@ -0,0 +1,53 @@
+<%#
+ 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.
+-%>
+<%#
+ This is a fragment file, it will be merged into to root template if available.
+ EJS fragments will process % delimiter tags in template and & delimiter tags in the merge process.
+-%>
+<&_ if (fragment.othersSection) { -&>
+### About Native Build
+
+#### Installation
+
+To build a Native image, you need to install a JDK that is compatible with GraalVM. Please refer to the [GraalVM Release Notes](https://www.graalvm.org/release-notes/) and install the appropriate JDK. Using SDKMAN simplifies the installation process.
+```
+sdk install java 21-graalce
+```
+#### How to Build a Native Image
+
+To build a native image, execute the following command:
+```bash
+npm run native-package
+# <%- packageJsonScripts['native-package'] %>
+```
+
+After that, set up peripheral services like PostgreSQL using `npm run services:up`(<%- packageJsonScripts['services:up'] %>) and ensure everything is ready.
+
+Lastly, run the Native image and experience its fast startup 😊.
+```bash
+npm run native-start
+# <%- packageJsonScripts['native-start'] %>
+```
+
+If you've enabled e2e testing with Cypress, you can verify its operation using the following command:
+```bash
+npm run native-e2e
+# <%- packageJsonScripts['native-e2e'] %>
+```
+<&_ } -&>

package/dist/generators/java/generators/graalvm/templates/gradle/native.gradle.ejs

@@ -0,0 +1,44 @@
+graalvmNative {
+  toolchainDetection = true
+  binaries {
+    main {
+      imageName = 'native-executable'
+      //this is only needed when you toolchain can't be detected
+      //javaLauncher = javaToolchains.launcherFor {
+      //  languageVersion = JavaLanguageVersion.of(19)
+      //  vendor = JvmVendorSpec.matching("GraalVM Community")
+      //}
+      buildArgs.add("-Duser.language=<%- nativeLanguageDefinition.languageTag %>")
+      buildArgs.add("-H:IncludeLocales=<%- languagesDefinition.map(def => def.languageTag).join(',') %>")
+    }
+  }
+  binaries.all {
+    verbose = true
+    jvmArgs.add('-Xms4g')
+    jvmArgs.add('-Xmx10g')
+  }
+}
+
+processTestAot {
+  jvmArgs += ["-XX:+AllowRedefinitionToAddDeleteMethods"]
+}
+<%_ if (!reactive && databaseTypeSql) { _%>
+  <%_ if (devDatabaseTypeH2Any) { _%>
+
+processResources {
+  filesMatching("**/application-dev.yml") {
+    filter {
+      it.replace("@spring.h2.console.enabled@", String.valueOf(!project.hasProperty("native")))
+    }
+  }
+}
+  <%_ } _%>
+
+if (project.hasProperty("native")) {
+  hibernate {
+    enhancement {
+      enableLazyInitialization = true
+    }
+  }
+}
+<%_ } _%>

package/dist/generators/java/generators/graalvm/templates/src/main/java/_package_/config/NativeConfiguration.java.ejs

@@ -0,0 +1,14 @@
+package <%=packageName%>.config;
+
+import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.RuntimeHintsRegistrar;
+
+public class NativeConfiguration {
+
+    public static class JHipsterNativeRuntimeHints implements RuntimeHintsRegistrar {
+        @Override
+        public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
+            // jhipster-needle-add-native-hints - JHipster will add native hints here
+        }
+    }
+}

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

@@ -1,24 +1,12 @@
-/**
- * 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 BaseApplicationGenerator from '../../../base-application/index.js';
 export default class NodeGenerator extends BaseApplicationGenerator {
     beforeQueue(): Promise<void>;
     get composing(): import("../../../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../../../lib/types/base/tasks.js").TaskParamWithControl, "compose">;
+    get postPreparing(): import("../../../../lib/types/base/tasks.js").GenericTaskGroup<any, import("../../../../lib/types/base/tasks.js").TaskParamWithControl & {
+        source: import("../../../../lib/types/application/application.js").BaseApplicationSource;
+    } & {
+        application: import("../../../../lib/types/application/application.js").ApplicationType<import("../../../base-application/index.js").Entity<import("../../../base-application/index.js").Field, never>>;
+    }, "useNpmWrapper">;
     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>>>, "writing">;
+    useNpmWrapperInstallTask(): void;
 }

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

@@ -16,6 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import chalk from 'chalk';
 import BaseApplicationGenerator from '../../../base-application/index.js';
 export default class NodeGenerator extends BaseApplicationGenerator {
     async beforeQueue() {
@@ -43,6 +44,18 @@ export default class NodeGenerator extends BaseApplicationGenerator {
     get [BaseApplicationGenerator.COMPOSING]() {
         return this.delegateTasksToBlueprint(() => this.composing);
     }
+    get postPreparing() {
+        return this.asPostPreparingTaskGroup({
+            useNpmWrapper({ application }) {
+                if (application.useNpmWrapper) {
+                    this.useNpmWrapperInstallTask();
+                }
+            },
+        });
+    }
+    get [BaseApplicationGenerator.POST_PREPARING]() {
+        return this.delegateTasksToBlueprint(() => this.postPreparing);
+    }
     get writing() {
         return this.asWritingTaskGroup({
             async writing({ application }) {
@@ -62,4 +75,22 @@ export default class NodeGenerator extends BaseApplicationGenerator {
     get [BaseApplicationGenerator.WRITING]() {
         return this.delegateTasksToBlueprint(() => this.writing);
     }
+    useNpmWrapperInstallTask() {
+        this.setFeatures({
+            customInstallTask: async (preferredPm, defaultInstallTask) => {
+                const buildTool = this.jhipsterConfigWithDefaults.buildTool;
+                if ((preferredPm && preferredPm !== 'npm') || this.jhipsterConfig.skipClient || (buildTool !== 'gradle' && buildTool !== 'maven')) {
+                    await defaultInstallTask();
+                    return;
+                }
+                const npmCommand = process.platform === 'win32' ? 'npmw' : './npmw';
+                try {
+                    await this.spawn(npmCommand, ['install'], { preferLocal: true });
+                }
+                catch (error) {
+                    this.log.error(chalk.red(`Error executing '${npmCommand} install', please execute it yourself. (${error.shortMessage})`));
+                }
+            },
+        });
+    }
 }

package/dist/generators/java/generators/openapi-generator/generator.js

@@ -31,8 +31,8 @@ export default class OpenapiGeneratorGenerator extends BaseApplicationGenerator
     }
     get writing() {
         return this.asWritingTaskGroup({
-            cleanup({ application, control }) {
-                control.cleanupFiles({
+            async cleanup({ application, control }) {
+                await control.cleanupFiles({
                     '8.6.1': [[application.buildToolGradle, 'gradle/swagger.gradle']],
                 });
             },

package/dist/generators/java/support/util.d.ts

@@ -3,4 +3,4 @@
  */
 export declare const getMainClassName: ({ baseName }: {
     baseName: string;
-}) => string;
+}) => Capitalize<string> | "Application";

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

@@ -28,7 +28,10 @@ export type JavaArtifact = {
 
 export type JavaArtifactVersion = RequireOneOrNone<{ version?: string; versionRef?: string }, 'version' | 'versionRef'>;
 
-export type JavaDependency = JavaArtifact & JavaArtifactVersion;
+export type JavaDependency = JavaArtifact &
+  JavaArtifactVersion & {
+    exclusions?: JavaArtifact[];
+  };
 
 export type JavaDefinition = {
   versions?: JavaDependencyVersion[];