generator-jhipster 8.2.1 → 8.3.0

package/dist/generators/vue/templates/src/main/webapp/app/account/account.service.spec.ts.ejs

@@ -81,7 +81,7 @@ describe('Account Service test suite', () => {
   });
 
   it('should init service and check for authority after retrieving account', async () => {
-    axiosStub.get.resolves({ status: 200, data: { authorities: ['USER'], langKey: 'en' } });
+    axiosStub.get.resolves({ status: 200, data: { authorities: ['USER'], langKey: 'en', login: 'ADMIN' } });
     accountService = new AccountService(store);
     await accountService.update();
 

package/dist/generators/vue/templates/src/main/webapp/app/account/account.service.ts.ejs

@@ -29,7 +29,7 @@ export default class AccountService {
   public async retrieveAccount(): Promise<boolean> {
     try {
       const response = await axios.get<any>('api/account');
-      if (response.status === 200 && response.data) {
+      if (response.status === 200 && response.data?.login) {
         const account = response.data;
         this.store.setAuthentication(account);
         return true;

package/dist/generators/vue/templates/src/main/webapp/app/admin/tracker/tracker.service.ts.ejs

@@ -1,6 +1,6 @@
 import { type ComputedRef, inject, ref, watch } from 'vue';
 import { useRouter } from 'vue-router';
-import * as SockJS from 'sockjs-client';
+import <% if (microfrontend) { %>* as <% } %>SockJS from 'sockjs-client';
 import { map } from 'rxjs';
 import { RxStomp, RxStompState } from '@stomp/rx-stomp';
 import Cookies from 'js-cookie';
@@ -8,9 +8,9 @@ import Cookies from 'js-cookie';
 const DESTINATION_TRACKER = '/topic/tracker';
 const DESTINATION_ACTIVITY = '/topic/activity';
 
-export const useTrackerService = ({ stomp }: { stomp?: RxStomp } = {}) => {
+export const useTrackerService = ({ stomp, authenticated }: { stomp?: RxStomp; authenticated?: ComputedRef<boolean> } = {}) => {
   const router = useRouter();
-  const authenticated = inject<ComputedRef<boolean>>('authenticated');
+  authenticated = authenticated ?? inject('authenticated');
   const trackerService = new TrackerService({ stomp });
 
   router.afterEach(to => trackerService.sendActivity(to.fullPath));

package/dist/generators/vue/templates/src/main/webapp/app/admin/tracker/tracker.vue.ejs

@@ -1,9 +1,9 @@
 <template>
     <div>
-        <h2 id="tracker-page-heading" v-text="t$('tracker.title')">Real-time user activities</h2>
+        <h2 id="tracker-page-heading" v-text="t$('tracker.title')" data-cy="trackerPageHeading">Real-time user activities</h2>
 
         <div class="table-responsive">
-            <table class="table table-striped">
+            <table class="table table-striped" data-cy="trackerTable">
                 <thead>
                 <tr>
                     <th v-text="t$('tracker.table.userlogin')">User</th>

package/dist/generators/vue/templates/src/main/webapp/app/main.ts.ejs

@@ -1,7 +1,7 @@
 // The Vue build version to load with the `import` command
 // (runtime-only or standalone) has been set in webpack.common with an alias.
 import Vue, { createApp, provide, computed, watch<% if (enableTranslation) { %>, onMounted<% } %> } from 'vue';
-import { createPinia } from 'pinia'
+import { createPinia, storeToRefs } from 'pinia'
 <%_ if (enableTranslation) { _%>
 import { useI18n } from 'vue-i18n';
 <%_ } _%>
@@ -169,7 +169,8 @@ const app = createApp({
       }
     );
 
-    provide('authenticated', computed(() => store.authenticated));
+    const { authenticated } = storeToRefs(store);
+    provide('authenticated', authenticated);
     provide('currentUsername', computed(() => store.account?.login));
 
 <%_ if (enableTranslation) { _%>
@@ -179,7 +180,7 @@ const app = createApp({
     // jhipster-needle-add-entity-service-to-main - JHipster will import entities services here
 <%_ if (communicationSpringWebsocket) { _%>
 
-    provide('trackerService', useTrackerService());
+    provide('trackerService', useTrackerService({ authenticated }));
 <%_ } _%>
 <%_ if (applicationTypeMicroservice && microfrontend) { _%>
     provide('microfrontendI18n', false);

package/dist/generators/vue/templates/vite.config.mts.ejs

@@ -102,11 +102,17 @@ let config = defineConfig({
 <%_ } _%>
 <%_ if (applicationTypeGateway || applicationTypeMicroservice) { _%>
         '/services',
+<%_ } _%>
+<%_ if (communicationSpringWebsocket) { _%>
+        '/websocket',
 <%_ } _%>
       ].map(res => [
         res,
         {
           target: 'http://localhost:<%= applicationTypeMicroservice ? gatewayServerPort : serverPort %>',
+<%_ if (communicationSpringWebsocket) { _%>
+          ws: res === '/websocket',
+<%_ } _%>
         },
       ])
     ),

package/dist/generators/workspaces/generator.js

@@ -17,9 +17,8 @@
  * limitations under the License.
  */
 import { existsSync } from 'fs';
-import { GENERATOR_ANGULAR, GENERATOR_BOOTSTRAP_WORKSPACES, GENERATOR_GIT, GENERATOR_WORKSPACES } from '../generator-list.js';
+import { GENERATOR_ANGULAR, GENERATOR_BOOTSTRAP_WORKSPACES, GENERATOR_GIT } from '../generator-list.js';
 import BaseWorkspacesGenerator from '../base-workspaces/index.js';
-import command from './command.js';
 /**
  * Base class for a generator that can be extended through a blueprint.
  *
@@ -34,7 +33,7 @@ export default class WorkspacesGenerator extends BaseWorkspacesGenerator {
     generateWorkspaces;
     async beforeQueue() {
         if (!this.fromBlueprint) {
-            await this.composeWithBlueprints(GENERATOR_WORKSPACES);
+            await this.composeWithBlueprints();
         }
         if (!this.delegateToBlueprint) {
             await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_WORKSPACES, { generatorOptions: { customWorkspacesConfig: true } });
@@ -42,8 +41,10 @@ export default class WorkspacesGenerator extends BaseWorkspacesGenerator {
     }
     get initializing() {
         return this.asInitializingTaskGroup({
+            async parseCommand() {
+                await this.parseCurrentJHipsterCommand();
+            },
             loadConfig() {
-                this.parseJHipsterOptions(command.options);
                 // Generate workspaces file if workspace option is passed, or if workspace option is ommitted and monorepository is enabled, or if regenerating.
                 this.generateWorkspaces = (this.workspaces ?? this.jhipsterConfig.monorepository) || Boolean(this.packageJson?.get('workspaces'));
                 // When generating workspaces, save to .yo-rc.json. Use a dummy config otherwise.

package/dist/jdl/converters/jdl-to-json/jdl-to-json-field-converter.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { capitalize } from 'lodash-es';
 import { validations } from '../../jhipster/index.js';
 import formatComment from '../../utils/format-utils.js';
 import { camelCase } from '../../utils/string-utils.js';
@@ -117,7 +117,7 @@ function getFieldValidations(jdlField) {
     jdlField.forEachValidation(validation => {
         fieldValidations.fieldValidateRules.push(validation.name);
         if (validation.name !== REQUIRED && validation.name !== UNIQUE) {
-            fieldValidations[`fieldValidateRules${_.capitalize(validation.name)}`] = validation.value;
+            fieldValidations[`fieldValidateRules${capitalize(validation.name)}`] = validation.value;
         }
     });
     return fieldValidations;

package/dist/jdl/converters/jdl-to-json/jdl-to-json-relationship-converter.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { kebabCase } from 'lodash-es';
 import { relationshipOptions, validations } from '../../jhipster/index.js';
 import { camelCase, lowerFirst } from '../../utils/string-utils.js';
 const { Validations: { REQUIRED }, } = validations;
@@ -66,7 +66,7 @@ function setRelationshipsFromEntity(relatedRelationships, entityName) {
         const otherSplitField = extractField(relationshipToConvert.injectedFieldInTo);
         const convertedRelationship = {
             relationshipSide: 'left',
-            relationshipType: _.kebabCase(relationshipToConvert.type),
+            relationshipType: kebabCase(relationshipToConvert.type),
             otherEntityName: camelCase(relationshipToConvert.to),
         };
         if (otherSplitField.relationshipName) {
@@ -94,7 +94,7 @@ function setRelationshipsToEntity(relatedRelationships, entityName) {
         const otherSplitField = extractField(relationshipToConvert.injectedFieldInFrom);
         const convertedRelationship = {
             relationshipSide: 'right',
-            relationshipType: otherRelationshipType(_.kebabCase(relationshipToConvert.type)),
+            relationshipType: otherRelationshipType(kebabCase(relationshipToConvert.type)),
             otherEntityName: camelCase(relationshipToConvert.from),
         };
         if (otherSplitField.relationshipName) {

package/dist/jdl/converters/parsed-jdl-to-jdl-object/parsed-jdl-to-jdl-object-converter.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { lowerFirst } from 'lodash-es';
 import JDLObject from '../../models/jdl-object.js';
 import JDLBinaryOption from '../../models/jdl-binary-option.js';
 import { applicationTypes, binaryOptions } from '../../jhipster/index.js';
@@ -128,7 +128,7 @@ function fillAssociations() {
 function convertAnnotationsToOptions(annotations) {
     const result = {};
     annotations.forEach(annotation => {
-        const annotationName = _.lowerFirst(annotation.optionName);
+        const annotationName = lowerFirst(annotation.optionName);
         const value = annotation.optionValue ? annotation.optionValue : true;
         if (annotationName in result) {
             const previousValue = result[annotationName];

package/dist/jdl/jdl-importer.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { uniqBy } from 'lodash-es';
 import * as JDLReader from './readers/jdl-reader.js';
 import ParsedJDLToJDLObjectConverter from './converters/parsed-jdl-to-jdl-object/parsed-jdl-to-jdl-object-converter.js';
 import { readJSONFile } from './readers/json-file-reader.js';
@@ -31,7 +31,6 @@ import createWithoutApplicationValidator from './validators/jdl-without-applicat
 import { applicationOptions } from './jhipster/index.js';
 const { OptionNames } = applicationOptions;
 const { APPLICATION_TYPE, BASE_NAME } = OptionNames;
-const { uniqBy } = _;
 /**
  * Creates a new JDL importer from files.
  * There are two ways to create an importer:

package/dist/jdl/jhipster/default-application-options.js

@@ -187,8 +187,8 @@ export function getServerConfigForGatewayApplication(customOptions = {}) {
     options[CACHE_PROVIDER] = NO_CACHE_PROVIDER;
     options[ENABLE_HIBERNATE_CACHE] = false;
     return {
-        ...options,
         [REACTIVE]: true,
+        ...options,
         [APPLICATION_TYPE]: GATEWAY,
     };
 }

package/dist/jdl/jhipster/field-types.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { snakeCase } from 'lodash-es';
 import validations from './validations.js';
 import JDLEnum from '../models/jdl-enum.js';
 import databaseTypes from './database-types.js';
@@ -84,7 +84,7 @@ export function isCommonDBType(type) {
     if (!type) {
         throw new Error('The passed type must not be nil.');
     }
-    return _.snakeCase(type).toUpperCase() in CommonDBTypes || type instanceof JDLEnum;
+    return snakeCase(type).toUpperCase() in CommonDBTypes || type instanceof JDLEnum;
 }
 export function isBlobType(type) {
     if (!type) {

package/dist/jdl/jhipster/relationship-types.js

@@ -16,9 +16,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { camelCase, upperFirst } from 'lodash-es';
 import { relationshipTypes } from '../basic-types/relationships.js';
-const { camelCase, upperFirst } = _;
 export const asJdlRelationshipType = (type) => upperFirst(camelCase(type));
 export const relationshipTypeExists = (relationship) => Object.values(relationshipTypes).includes(relationship);
 export default relationshipTypes;

package/dist/jdl/models/jdl-deployment.js

@@ -16,12 +16,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { isEqual } from 'lodash-es';
 import { deploymentOptions, applicationOptions, serviceDiscoveryTypes } from '../jhipster/index.js';
 import { merge } from '../utils/object-utils.js';
 import { join } from '../utils/set-utils.js';
 const { Options } = deploymentOptions;
-const { isEqual } = _;
 const arrayTypes = ['appsFolders', 'clusteredDbApps'];
 const NO_SERVICE_DISCOVERY = serviceDiscoveryTypes.NO;
 export default class JDLDeployment {

package/dist/jdl/parsing/api.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { uniq } from 'lodash-es';
 import { EOF } from 'chevrotain';
 import JDLAstBuilderVisitor from './jdl-ast-builder-visitor.js';
 import { JDLLexer, tokens } from './lexer/lexer.js';
@@ -78,5 +78,5 @@ export function getSyntacticAutoCompleteSuggestions(input, startRule = 'prog') {
     // Each suggestion includes additional information such as the "Rule Stack" at suggestion point.
     // This may be handy for advanced implementations, e.g: different logic for suggesting a NAME token in an entity
     // or a field. But it is irrelevant in the scope of the POC.
-    return _.uniq(syntacticSuggestions.map(suggestion => suggestion.nextTokenType));
+    return uniq(syntacticSuggestions.map(suggestion => suggestion.nextTokenType));
 }

package/dist/jdl/parsing/lexer/token-creator.js

@@ -16,10 +16,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { isString } from 'lodash-es';
 import { createToken } from 'chevrotain';
 import { NAME, KEYWORD, namePattern } from './shared-tokens.js';
-const { isString } = _;
 export default function createTokenFromConfig(config) {
     if (!config) {
         throw new Error("Can't create a token without the proper config.");

package/dist/jdl/parsing/self-checks/parsing-system-checker.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { difference, flatMap, includes, isEmpty, reject, some, uniq, values } from 'lodash-es';
 import { Lexer } from 'chevrotain';
 import TokenCollectorVisitor from './token-collector-visitor.js';
 export function checkTokens(allDefinedTokens, rules) {
@@ -31,37 +31,37 @@ function getUsedTokens(rules) {
     return rules.reduce((result, currentRule) => {
         const collector = new TokenCollectorVisitor();
         currentRule.accept(collector);
-        return _.uniq(result.concat(collector.actualTokens));
+        return uniq(result.concat(collector.actualTokens));
     }, []);
 }
 function getUselessTokens(usedTokens, allDefinedTokens) {
-    const usedCategories = _.uniq(_.flatMap(usedTokens, 'CATEGORIES'));
+    const usedCategories = uniq(flatMap(usedTokens, 'CATEGORIES'));
     // TODO: Calling uniq with two parameters is probably a bug.
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error
-    const notDirectlyUsedTokens = _.difference(allDefinedTokens, _.uniq(usedTokens, usedCategories));
-    const redundant = _.reject(notDirectlyUsedTokens, token => {
+    const notDirectlyUsedTokens = difference(allDefinedTokens, uniq(usedTokens, usedCategories));
+    const redundant = reject(notDirectlyUsedTokens, token => {
         const tokCategories = token.CATEGORIES;
-        return _.some(tokCategories, category => _.includes(usedCategories, category));
+        return some(tokCategories, category => includes(usedCategories, category));
     });
-    return _.reject(redundant, tokenType => tokenType.GROUP === Lexer.SKIPPED);
+    return reject(redundant, tokenType => tokenType.GROUP === Lexer.SKIPPED);
 }
 export function checkConfigKeys(definedTokensMap, usedConfigKeys) {
     checkForUselessConfigurationKeys(definedTokensMap, usedConfigKeys);
     checkForMissingConfigurationKeys(definedTokensMap, usedConfigKeys);
 }
 function checkForUselessConfigurationKeys(definedTokensMap, usedConfigKeys) {
-    const redundantConfigKeys = _.difference(usedConfigKeys, Object.keys(definedTokensMap));
-    if (!_.isEmpty(redundantConfigKeys)) {
+    const redundantConfigKeys = difference(usedConfigKeys, Object.keys(definedTokensMap));
+    if (!isEmpty(redundantConfigKeys)) {
         throw Error(`Useless configuration keys: [ ${redundantConfigKeys.join(', ')} ]`);
     }
 }
 function checkForMissingConfigurationKeys(definedTokensMap, usedConfigKeys) {
-    const definedConfigKeyNames = _.values(definedTokensMap)
-        .filter(tokenType => _.includes(tokenType.CATEGORIES, definedTokensMap.CONFIG_KEY))
+    const definedConfigKeyNames = values(definedTokensMap)
+        .filter(tokenType => includes(tokenType.CATEGORIES, definedTokensMap.CONFIG_KEY))
         .map(tokenType => tokenType.name);
-    const missingConfigKeys = _.difference(definedConfigKeyNames, usedConfigKeys);
-    if (!_.isEmpty(missingConfigKeys)) {
+    const missingConfigKeys = difference(definedConfigKeyNames, usedConfigKeys);
+    if (!isEmpty(missingConfigKeys)) {
         throw Error(`Missing configuration keys: [ ${missingConfigKeys.join(', ')} ]`);
     }
 }

package/dist/jdl/parsing/validator.js

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 /* eslint-disable no-useless-escape */
-import * as _ from 'lodash-es';
+import { first, flatten, includes, values } from 'lodash-es';
 import { tokenMatcher as matchesToken } from 'chevrotain';
 import JDLParser from './jdl-parser.js';
 import { tokens as LexerTokens } from './lexer/lexer.js';
@@ -351,7 +351,7 @@ class JDLSyntaxValidatorVisitor extends BaseJDLCSTVisitorWithDefaults {
                 if (actual.name !== 'qualifiedName' &&
                     // a Boolean (true/false) is also a valid name.
                     actual.tokenType &&
-                    !_.includes(actual.tokenType.CATEGORIES, LexerTokens.BOOLEAN)) {
+                    !includes(actual.tokenType.CATEGORIES, LexerTokens.BOOLEAN)) {
                     this.errors.push({
                         message: `A name is expected, but found: "${getFirstToken(actual).image}"`,
                         token: getFirstToken(actual),
@@ -517,14 +517,14 @@ class JDLSyntaxValidatorVisitor extends BaseJDLCSTVisitorWithDefaults {
         this.visit(context.configValue, context.CONFIG_KEY[0]);
     }
     configValue(context, configKey) {
-        const configValue = _.first(_.first(Object.values(context)));
+        const configValue = first(first(Object.values(context)));
         this.checkConfigPropSyntax(configKey, configValue);
     }
     deploymentConfigDeclaration(context) {
         this.visit(context.deploymentConfigValue, context.DEPLOYMENT_KEY[0]);
     }
     deploymentConfigValue(context, configKey) {
-        const configValue = _.first(_.first(_.values(context)));
+        const configValue = first(first(values(context)));
         this.checkDeploymentConfigPropSyntax(configKey, configValue);
     }
 }
@@ -542,5 +542,5 @@ function getFirstToken(tokOrCstNode) {
         return tokOrCstNode;
     }
     // CST Node - - assumes no nested CST Nodes, only terminals
-    return _.flatten(Object.values(tokOrCstNode.children)).reduce((firstTok, nextTok) => (firstTok.startOffset > nextTok.startOffset ? nextTok : firstTok), { startOffset: Infinity });
+    return flatten(Object.values(tokOrCstNode.children)).reduce((firstTok, nextTok) => (firstTok.startOffset > nextTok.startOffset ? nextTok : firstTok), { startOffset: Infinity });
 }

package/dist/testing/get-generator.js

@@ -4,7 +4,7 @@ import { existsSync } from 'fs';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export const getGeneratorFolder = (generatorName) => {
-    return resolve(__dirname, '../generators', generatorName);
+    return resolve(__dirname, '../generators', generatorName.split(':').join('/generators/'));
 };
 const getGenerator = (generatorName) => {
     const generatorFolder = getGeneratorFolder(generatorName);

package/dist/testing/helpers.js

@@ -1,6 +1,8 @@
 import { YeomanTest, RunContext, result } from 'yeoman-test';
-import * as _ from 'lodash-es';
-import { basename, join } from 'path';
+import { merge, set } from 'lodash-es';
+import { globSync } from 'glob';
+import { basename, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import EnvironmentBuilder from '../cli/environment-builder.mjs';
 import { JHIPSTER_CONFIG_DIR } from '../generators/generator-constants.js';
 import { GENERATOR_WORKSPACES } from '../generators/generator-list.js';
@@ -8,12 +10,20 @@ import getGenerator from './get-generator.js';
 import { createJHipsterLogger, normalizePathEnd, parseCreationTimestamp } from '../generators/base/support/index.js';
 import BaseGenerator from '../generators/base/index.js';
 import { getPackageRoot, isDistFolder } from '../lib/index.js';
-const { set } = _;
 const runResult = result;
 export { runResult, runResult as result };
 const DEFAULT_TEST_SETTINGS = { forwardCwd: true };
 const DEFAULT_TEST_OPTIONS = { skipInstall: true };
 const DEFAULT_TEST_ENV_OPTIONS = { skipInstall: true, dryRun: false };
+const generatorsDir = join(fileURLToPath(import.meta.url), '../../generators');
+const mockedGenerators = [
+    ...globSync('*/index.{j,t}s', { cwd: generatorsDir, posix: true }).map(file => dirname(file)),
+    ...globSync('*/generators/*/index.{j,t}s', { cwd: generatorsDir, posix: true }).map(file => dirname(file).replace('/generators/', ':')),
+]
+    .filter(gen => !gen.startsWith('bootstrap-'))
+    .map(gen => `jhipster:${gen}`)
+    .sort();
+const defaultSharedApplication = Object.fromEntries(['CLIENT_WEBPACK_DIR'].map(key => [key, undefined]));
 let defaultMockFactory;
 export const defineDefaults = async ({ mockFactory } = {}) => {
     if (mockFactory) {
@@ -165,10 +175,25 @@ class JHipsterRunContext extends RunContext {
         return this.withSharedData({ control: this.sharedControl });
     }
     withSharedApplication(sharedApplication) {
-        this.sharedApplication = this.sharedApplication ?? {};
-        Object.assign(this.sharedApplication, sharedApplication);
+        this.sharedApplication = this.sharedApplication ?? { ...defaultSharedApplication };
+        merge(this.sharedApplication, sharedApplication);
         return this.withSharedData({ sharedApplication: this.sharedApplication });
     }
+    withMockedJHipsterGenerators(exceptList = []) {
+        return this.withMockedGenerators(mockedGenerators.filter(gen => !exceptList.includes(gen) && this.Generator !== gen));
+    }
+    withGradleBuildTool() {
+        return this.withFiles({
+            'build.gradle': `
+dependencies {
+// jhipster-needle-gradle-dependency
+}
+plugins {
+// jhipster-needle-gradle-plugins
+}
+`,
+        }).withJHipsterConfig({ buildTool: 'gradle' });
+    }
     withSharedData(sharedData) {
         if (!this.sharedData) {
             const applicationId = 'test-application';
@@ -182,7 +207,7 @@ class JHipsterRunContext extends RunContext {
         return this;
     }
     async run() {
-        const runResult = await super.run();
+        const runResult = (await super.run());
         if (this.sharedSource) {
             const sourceCallsArg = Object.fromEntries(Object.entries(this.sharedSource).map(([name, fn]) => [name, fn.mock.calls.map(args => args[0])]));
             if (sourceCallsArg.addEntitiesToClient) {
@@ -197,9 +222,9 @@ class JHipsterRunContext extends RunContext {
                     relationships: relationships.map(rel => `Relationship[${rel.relationshipName}]`),
                 }));
             }
-            const jhipsterRunResult = runResult;
-            jhipsterRunResult.sourceCallsArg = sourceCallsArg;
+            runResult.sourceCallsArg = sourceCallsArg;
         }
+        runResult.composedMockedGenerators = mockedGenerators.filter(gen => runResult.mockedGenerators[gen]?.called && !['jhipster:bootstrap', 'jhipster:project-name'].includes(gen));
         return runResult;
     }
 }
@@ -220,7 +245,7 @@ class JHipsterTest extends YeomanTest {
         class BlueprintedGenerator extends BaseGenerator {
             async beforeQueue() {
                 if (!this.fromBlueprint) {
-                    await this.composeWithBlueprints('test-blueprint');
+                    await this.composeWithBlueprints();
                 }
             }
             rootGeneratorName() {

package/dist/types/generators/angular/support/index.d.ts

@@ -20,5 +20,4 @@ export * from './needles.js';
 export * from './path-utils.js';
 export * from './reserved-keywords.js';
 export * from './translate-angular.js';
-export { default as translateAngularFilesTransform } from './translate-angular.js';
 export { default as updateLanguagesTask } from './update-languages.js';

package/dist/types/generators/angular/support/translate-angular.d.ts

@@ -1,11 +1,14 @@
 /// <reference types="node" resolution-mode="require"/>
+export type ReplacerOptions = {
+    jhiPrefix: string;
+    enableTranslation: boolean;
+};
 /**
  * Replace and cleanup translations.
  *
  * @type {import('../generator-base.js').EditFileCallback}
  * @this {import('../generator-base.js')}
  */
-export const createTranslationReplacer: any;
-export function isTranslatedAngularFile(file: any): boolean;
-export default translateAngularFilesTransform;
-declare function translateAngularFilesTransform(getWebappTranslation: any, enableTranslation: any): import("stream").Transform;
+export declare const createTranslationReplacer: (getWebappTranslation: any, opts: ReplacerOptions | boolean) => (content: any, filePath: any) => any;
+export declare const isTranslatedAngularFile: (file: any) => boolean;
+export declare const translateAngularFilesTransform: (getWebappTranslation: any, opts: ReplacerOptions | boolean) => import("stream").Transform;

package/dist/types/generators/app/support/config.d.ts

@@ -17,7 +17,7 @@ export declare function loadStoredAppOptions(this: any, { options, jhipsterConfi
 export declare const loadAppConfig: ({ config, application, useVersionPlaceholders, }: {
     config: any;
     application: any;
-    useVersionPlaceholders?: boolean | undefined;
+    useVersionPlaceholders?: boolean;
 }) => void;
 /**
  * @param {Object} dest - destination context to use default is context

package/dist/types/generators/base/api.d.ts

@@ -196,6 +196,7 @@ export type PromptSpec = {
   default?: any | ((any) => any);
   filter?: any | ((any) => any);
   transformer?: any | ((any) => any);
+  validate?: any | ((any) => any);
 };
 
 export type JHipsterArgumentConfig = SetOptional<ArgumentSpec, 'name'> & { scope?: 'storage' | 'blueprint' | 'generator' };
@@ -231,6 +232,12 @@ export type JHipsterCommandDefinition = {
    * @example ['server', 'jhipster-blueprint:server']
    */
   import?: string[];
+  /**
+   * @experimental
+   * Compose with generator.
+   * @example ['server', 'jhipster-blueprint:server']
+   */
+  compose?: string[];
   /**
    * Override options from the generator been blueprinted.
    */

package/dist/types/generators/base/generator.d.ts

@@ -1,6 +1,6 @@
 import type { ComposeOptions } from 'yeoman-generator';
 import { BaseGeneratorDefinition, GenericTaskGroup } from './tasks.js';
-import { JHipsterGeneratorFeatures, JHipsterGeneratorOptions } from './api.js';
+import type { JHipsterGeneratorFeatures, JHipsterGeneratorOptions } from './api.js';
 import CoreGenerator from '../base-core/index.js';
 /**
  * Base class that contains blueprints support.

package/dist/types/generators/base-application/generator.d.ts

@@ -27,10 +27,10 @@ export default class BaseApplicationGenerator<Definition extends BaseApplication
     static WRITING_ENTITIES: string;
     static POST_WRITING_ENTITIES: string;
     constructor(args: string | string[], options: JHipsterGeneratorOptions, features: JHipsterGeneratorFeatures);
-    dependsOnBootstrapAplication(options?: ComposeOptions | undefined): Promise<import("@yeoman/types").BaseGenerator[]>;
-    dependsOnBootstrapAplicationBase(options?: ComposeOptions | undefined): Promise<import("@yeoman/types").BaseGenerator[]>;
-    dependsOnBootstrapAplicationServer(options?: ComposeOptions | undefined): Promise<import("@yeoman/types").BaseGenerator[]>;
-    dependsOnBootstrapAplicationClient(options?: ComposeOptions | undefined): Promise<import("@yeoman/types").BaseGenerator[]>;
+    dependsOnBootstrapApplication(options?: ComposeOptions | undefined): Promise<import("@yeoman/types").BaseGenerator[]>;
+    dependsOnBootstrapApplicationBase(options?: ComposeOptions | undefined): Promise<import("@yeoman/types").BaseGenerator[]>;
+    dependsOnBootstrapApplicationServer(options?: ComposeOptions | undefined): Promise<import("@yeoman/types").BaseGenerator[]>;
+    dependsOnBootstrapApplicationClient(options?: ComposeOptions | undefined): Promise<import("@yeoman/types").BaseGenerator[]>;
     /**
      * Get Entities configuration path
      * @returns

package/dist/types/generators/base-application/support/task-type-inference.d.ts

@@ -1,5 +1,8 @@
 import CoreGenerator from '../../base-core/generator.js';
+import { WriteFileSection, WriteFileBlock } from '../../base/api.js';
 import { GeneratorDefinition } from '../generator.js';
+export declare function asWriteFilesSection<Data = GeneratorDefinition['writingTaskParam']['application']>(section: WriteFileSection<CoreGenerator, Data>): WriteFileSection<CoreGenerator, Data>;
+export declare function asWriteFilesBlock<Data = GeneratorDefinition['writingTaskParam']['application']>(section: WriteFileBlock<CoreGenerator, Data>): WriteFileBlock<CoreGenerator, Data>;
 export declare function asInitializingTask(task: (this: CoreGenerator, params: GeneratorDefinition['initializingTaskParam']) => void): (this: CoreGenerator, params: GeneratorDefinition['initializingTaskParam']) => void;
 export declare function asPromptingTask(task: (this: CoreGenerator, params: GeneratorDefinition['promptingTaskParam']) => void): (this: CoreGenerator, params: GeneratorDefinition['promptingTaskParam']) => void;
 export declare function asConfiguringTask(task: (this: CoreGenerator, params: GeneratorDefinition['configuringTaskParam']) => void): (this: CoreGenerator, params: GeneratorDefinition['configuringTaskParam']) => void;

package/dist/types/generators/base-application/support/update-application-entities-transform.d.ts

@@ -1,4 +1,4 @@
 export declare const updateApplicationEntitiesTransform: ({ destinationPath, throwOnMissingConfig, }: {
     destinationPath: string;
-    throwOnMissingConfig?: boolean | undefined;
+    throwOnMissingConfig?: boolean;
 }) => import("p-transform").DuplexWithDebug;