generator-jhipster 8.2.1 → 8.4.0

package/dist/generators/base/support/needles.js

@@ -17,10 +17,8 @@
  * limitations under the License.
  */
 import assert from 'assert';
-import * as _ from 'lodash-es';
-import escapeStringRegexp from 'escape-string-regexp';
+import { escapeRegExp, kebabCase } from 'lodash-es';
 import { joinCallbacks } from './write-files.js';
-const { kebabCase } = _;
 /**
  * Change spaces sequences and '>' to allow any number of spaces or new line prefix
  */
@@ -40,10 +38,10 @@ export const checkContentIn = (contentToCheck, content, ignoreWhitespaces = true
     let re;
     if (typeof contentToCheck === 'string') {
         const pattern = ignoreWhitespaces
-            ? convertToPrettierExpressions(escapeStringRegexp(contentToCheck))
+            ? convertToPrettierExpressions(escapeRegExp(contentToCheck))
             : contentToCheck
                 .split('\n')
-                .map(line => `\\s*${escapeStringRegexp(line)}`)
+                .map(line => `\\s*${escapeRegExp(line)}`)
                 .join('\n');
         re = new RegExp(pattern);
     }

package/dist/generators/base/support/string.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 { camelCase, upperFirst } from 'lodash-es';
 /**
  * Calculate a hash code for a given string.
  * @param str - any string
@@ -39,5 +39,5 @@ export function stringHashCode(str) {
  * @param value string to convert
  */
 export function upperFirstCamelCase(value) {
-    return _.upperFirst(_.camelCase(value));
+    return upperFirst(camelCase(value));
 }

package/dist/generators/base-application/generator.js

@@ -68,16 +68,16 @@ export default class BaseApplicationGenerator extends BaseGenerator {
             delete this.options.applicationWithEntities;
         }
     }
-    dependsOnBootstrapAplication(options) {
+    dependsOnBootstrapApplication(options) {
         return this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION, options);
     }
-    dependsOnBootstrapAplicationBase(options) {
+    dependsOnBootstrapApplicationBase(options) {
         return this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_BASE, options);
     }
-    dependsOnBootstrapAplicationServer(options) {
+    dependsOnBootstrapApplicationServer(options) {
         return this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_SERVER, options);
     }
-    dependsOnBootstrapAplicationClient(options) {
+    dependsOnBootstrapApplicationClient(options) {
         return this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_CLIENT, options);
     }
     /**

package/dist/generators/base-application/support/entity.js

@@ -16,7 +16,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
-const { upperFirst } = _;
+import { upperFirst } from 'lodash-es';
 // eslint-disable-next-line import/prefer-default-export
 export const findEntityInEntities = (entityName, entities) => entities.find(entity => upperFirst(entity.name) === upperFirst(entityName));

package/dist/generators/base-application/support/enum.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 { formatDocAsJavaDoc } from '../../java/support/doc.js';
 const doesTheEnumValueHaveACustomValue = enumValue => {
     return enumValue.includes('(');
@@ -67,7 +67,7 @@ const getEnums = (enums, customValuesState, comments) => {
 };
 const extractEnumInstance = field => {
     const fieldType = field.fieldType;
-    return _.lowerFirst(fieldType);
+    return lowerFirst(fieldType);
 };
 const extractEnumEntries = field => {
     return field.fieldValues.split(',').map(fieldValue => fieldValue.trim());

package/dist/generators/base-application/support/prepare-entity.js

@@ -573,7 +573,7 @@ function preparePostEntityCommonDerivedPropertiesNotTyped(entity) {
     entity.containsBagRelationships = entity.relationships.some(relationship => relationship.bagRelationship);
     entity.implementsEagerLoadApis = // Cassandra doesn't provides *WithEagerRelationships apis
         ![CASSANDRA, COUCHBASE, NEO4J].includes(entity.databaseType) &&
-            // Only sql and mongodb provides *WithEagerReationships apis for imperative implementation
+            // Only sql and mongodb provides *WithEagerRelationships apis for imperative implementation
             (entity.reactive || [SQL, MONGODB].includes(entity.databaseType)) &&
             entity.relationshipsContainEagerLoad;
     entity.eagerRelations = entity.relationships.filter(rel => rel.relationshipEagerLoad);

package/dist/generators/base-application/support/prepare-field.js

@@ -16,8 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { snakeCase, startCase, upperFirst } from 'lodash-es';
-import * as _ from 'lodash-es';
+import { snakeCase, startCase, upperFirst, defaults, kebabCase } from 'lodash-es';
 import { fieldTypes, validations } from '../../../jdl/jhipster/index.js';
 import { getTypescriptType, prepareField as prepareClientFieldForTemplates } from '../../client/support/index.js';
 import { prepareField as prepareServerFieldForTemplates } from '../../server/support/index.js';
@@ -223,7 +222,7 @@ function _derivedProperties(field) {
     const fieldType = field.fieldType;
     const fieldTypeBlobContent = field.fieldTypeBlobContent;
     const validationRules = field.fieldValidate ? field.fieldValidateRules : [];
-    _.defaults(field, {
+    defaults(field, {
         blobContentTypeText: fieldTypeBlobContent === TEXT,
         blobContentTypeImage: fieldTypeBlobContent === IMAGE,
         blobContentTypeAny: fieldTypeBlobContent === ANY,
@@ -248,7 +247,7 @@ function _derivedProperties(field) {
         fieldTypeNumeric: fieldType === INTEGER || fieldType === LONG || fieldType === FLOAT || fieldType === DOUBLE || fieldType === BIG_DECIMAL,
         fieldTypeBinary: fieldType === BYTES || fieldType === BYTE_BUFFER,
         fieldTypeTimed: fieldType === ZONED_DATE_TIME || fieldType === INSTANT,
-        fieldTypeCharSequence: fieldType === STRING || fieldType === UUID,
+        fieldTypeCharSequence: fieldType === STRING || fieldType === UUID || fieldType === TEXT_BLOB,
         fieldTypeTemporal: fieldType === ZONED_DATE_TIME || fieldType === INSTANT || fieldType === LOCAL_DATE,
         fieldValidationRequired: validationRules.includes(REQUIRED),
         fieldValidationMin: validationRules.includes(MIN),
@@ -281,13 +280,13 @@ function prepareCommonFieldForTemplates(entityWithConfig, field, generator) {
         tsType: ({ fieldType }) => getTypescriptType(fieldType),
     });
     prepareProperty(field);
-    _.defaults(field, {
+    defaults(field, {
         entity: entityWithConfig,
     });
     const fieldType = field.fieldType;
     field.fieldIsEnum = !field.id && fieldIsEnum(fieldType);
     if (field.fieldIsEnum) {
-        field.enumFileName = _.kebabCase(field.fieldType);
+        field.enumFileName = kebabCase(field.fieldType);
         field.enumValues = getEnumValuesWithCustomValues(field.fieldValues);
     }
     field.fieldWithContentType = (fieldType === BYTES || fieldType === BYTE_BUFFER) && field.fieldTypeBlobContent !== TEXT;
@@ -295,7 +294,7 @@ function prepareCommonFieldForTemplates(entityWithConfig, field, generator) {
         field.contentTypeFieldName = `${field.fieldName}ContentType`;
     }
     field.fieldValidate = Array.isArray(field.fieldValidateRules) && field.fieldValidateRules.length >= 1;
-    _.defaults(field, {
+    defaults(field, {
         nullable: !(field.fieldValidate === true && field.fieldValidateRules.includes(REQUIRED)),
     });
     field.unique = field.fieldValidate === true && field.fieldValidateRules.includes(UNIQUE);

package/dist/generators/base-application/support/relationship.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 { upperFirst, lowerFirst } from 'lodash-es';
 import { stringifyApplicationData } from './debug.js';
 import { findEntityInEntities } from './entity.js';
-const { upperFirst, lowerFirst } = _;
 export const otherRelationshipType = relationshipType => relationshipType.split('-').reverse().join('-');
 export const findOtherRelationshipInRelationships = (entityName, relationship, inRelationships) => {
     return inRelationships.find(otherRelationship => {

package/dist/generators/base-application/support/task-type-inference.js

@@ -1,3 +1,9 @@
+export function asWriteFilesSection(section) {
+    return section;
+}
+export function asWriteFilesBlock(section) {
+    return section;
+}
 export function asInitializingTask(task) {
     return task;
 }

package/dist/generators/base-core/generator.js

@@ -25,8 +25,7 @@ import assert from 'assert';
 import { requireNamespace } from '@yeoman/namespace';
 import chalk from 'chalk';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
-import * as _ from 'lodash-es';
-import { kebabCase } from 'lodash-es';
+import { kebabCase, snakeCase, merge, get, set } from 'lodash-es';
 import { simpleGit } from 'simple-git';
 import semver, { lt as semverLessThan } from 'semver';
 import YeomanGenerator from 'yeoman-generator';
@@ -41,7 +40,7 @@ import command from '../base/command.js';
 import { GENERATOR_JHIPSTER, YO_RC_FILE } from '../generator-constants.js';
 import { convertConfigToOption } from '../../lib/internal/index.js';
 import { getGradleLibsVersionsProperties } from '../gradle/support/dependabot-gradle.js';
-const { merge, get, set } = _;
+import { dockerPlaceholderGenerator } from '../docker/utils.js';
 const { INITIALIZING, PROMPTING, CONFIGURING, COMPOSING, LOADING, PREPARING, POST_PREPARING, DEFAULT, WRITING, POST_WRITING, INSTALL, POST_INSTALL, END, } = PRIORITY_NAMES;
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -83,6 +82,13 @@ export default class CoreGenerator extends YeomanGenerator {
      */
     jhipsterTemplatesFolders;
     blueprintStorage;
+    /** Allow to use a specific definition at current command operations */
+    generatorCommand;
+    /**
+     * @experimental
+     * Additional commands to be considered
+     */
+    generatorsToCompose = [];
     _jhipsterGenerator;
     _needleApi;
     constructor(args, options, features) {
@@ -211,19 +217,75 @@ You can ignore this error by passing '--skip-checks' to jhipster command.`);
         }
         return priorities;
     }
-    async parseCurrentJHipsterCommand() {
-        const module = await this._meta?.importModule?.();
-        if (!module?.command) {
-            throw new Error(`Command not found for generator ${this.options.namespace}`);
+    /**
+     * Get the current Command Definition for the generator.
+     * `generatorCommand` takes precedence.
+     */
+    async getCurrentJHipsterCommand() {
+        if (!this.generatorCommand) {
+            const { command } = ((await this._meta?.importModule?.()) ?? {});
+            if (!command) {
+                throw new Error(`Command not found for generator ${this.options.namespace}`);
+            }
+            this.generatorCommand = command;
+            return command;
         }
-        this.parseJHipsterCommand(module?.command);
+        return this.generatorCommand;
     }
+    /**
+     * Parse command definition arguments, options and configs.
+     * Blueprints with command override takes precedence.
+     */
+    async parseCurrentJHipsterCommand() {
+        const generatorCommand = await this.getCurrentJHipsterCommand();
+        this.parseJHipsterCommand(generatorCommand);
+    }
+    /**
+     * Prompts for command definition configs.
+     * Blueprints with command override takes precedence.
+     */
     async promptCurrentJHipsterCommand() {
-        const module = await this._meta?.importModule?.();
-        if (!module?.command?.configs) {
+        const generatorCommand = await this.getCurrentJHipsterCommand();
+        if (!generatorCommand.configs) {
+            throw new Error(`Configs not found for generator ${this.options.namespace}`);
+        }
+        return this.prompt(this.prepareQuestions(generatorCommand.configs));
+    }
+    /**
+     * Load the current JHipster command storage configuration into the context.
+     * Blueprints with command override takes precedence.
+     */
+    async loadCurrentJHipsterCommandConfig(context) {
+        const generatorCommand = await this.getCurrentJHipsterCommand();
+        if (!generatorCommand.configs) {
             throw new Error(`Configs not found for generator ${this.options.namespace}`);
         }
-        return this.prompt(this.prepareQuestions(module?.command?.configs));
+        const config = this.jhipsterConfigWithDefaults;
+        Object.entries(generatorCommand.configs).forEach(([name, def]) => {
+            if (def.scope === 'storage') {
+                context[name] = context[name] ?? config?.[name] ?? this.config.get(name) ?? def.default;
+            }
+            if (def.scope === 'generator') {
+                context[name] = context[name] ?? this[name] ?? def.default;
+            }
+            if (def.scope === 'blueprint') {
+                context[name] = context[name] ?? this.blueprintStorage?.get(name) ?? def.default;
+            }
+        });
+    }
+    /**
+     * @experimental
+     * Compose the current JHipster command compose.
+     * Blueprints commands compose without generators will be composed.
+     */
+    async composeCurrentJHipsterCommand() {
+        const generatorCommand = await this.getCurrentJHipsterCommand();
+        for (const compose of generatorCommand.compose ?? []) {
+            await this.composeWithJHipster(compose);
+        }
+        for (const compose of this.generatorsToCompose) {
+            await this.composeWithJHipster(compose);
+        }
     }
     parseJHipsterCommand(commandDef) {
         if (commandDef.arguments) {
@@ -871,9 +933,19 @@ templates: ${JSON.stringify(existingTemplates, null, 2)}`;
     /**
      * Shallow clone or convert dependencies to placeholder if needed.
      */
-    prepareDependencies(map, valuePlaceholder = value => `${_.snakeCase(value).toUpperCase()}_VERSION`) {
+    prepareDependencies(map, valuePlaceholder) {
+        let placeholder;
+        if (valuePlaceholder === 'java') {
+            placeholder = value => `'${kebabCase(value).toUpperCase()}-VERSION'`;
+        }
+        else if (valuePlaceholder === 'docker') {
+            placeholder = dockerPlaceholderGenerator;
+        }
+        else {
+            placeholder = valuePlaceholder ?? (value => `${snakeCase(value).toUpperCase()}_VERSION`);
+        }
         if (this.useVersionPlaceholders) {
-            return Object.fromEntries(Object.keys(map).map(dep => [dep, valuePlaceholder(dep)]));
+            return Object.fromEntries(Object.keys(map).map(dep => [dep, placeholder(dep)]));
         }
         return {
             ...map,
@@ -894,7 +966,7 @@ templates: ${JSON.stringify(existingTemplates, null, 2)}`;
         }
         const gradleLibsVersions = this.readTemplate(gradleCatalog)?.toString();
         if (gradleLibsVersions) {
-            Object.assign(javaDependencies, this.prepareDependencies(getGradleLibsVersionsProperties(gradleLibsVersions), value => `'${kebabCase(value).toUpperCase()}-VERSION'`));
+            Object.assign(javaDependencies, this.prepareDependencies(getGradleLibsVersionsProperties(gradleLibsVersions), 'java'));
         }
     }
     loadNodeDependenciesFromPackageJson(destination, packageJsonFile = this.templatePath('../resources/package.json')) {

package/dist/generators/base-entity-changes/generator.js

@@ -33,6 +33,8 @@ const baseChangelog = () => ({
     addedRelationships: [],
     removedRelationships: [],
     relationshipsToRecreateForeignKeysOnly: [],
+    removedDefaultValueFields: [],
+    addedDefaultValueFields: [],
     changelogData: {},
 });
 /**
@@ -127,6 +129,20 @@ export default class GeneratorBaseEntityChanges extends GeneratorBaseApplication
             const relationshipsToRecreateForeignKeysOnly = addedRelationships
                 .filter(addedRelationship => removedRelationships.some(removedRelationship => relationshipNeedsForeignKeyRecreationOnly(removedRelationship, addedRelationship)))
                 .concat(removedRelationships.filter(removedRelationship => addedRelationships.some(addedRelationship => relationshipNeedsForeignKeyRecreationOnly(addedRelationship, removedRelationship))));
+            const oldFieldsWithDefaultValues = oldFields.filter(field => this.hasAnyDefaultValue(field));
+            const newFieldsWithDefaultValues = newFields.filter(field => this.hasAnyDefaultValue(field));
+            // find the old fields that have not been deleted anyway or otherwise where the default value is different on the same new field
+            const removedDefaultValueFields = oldFieldsWithDefaultValues
+                .filter(oldField => !removedFieldNames.includes(oldField.fieldName))
+                .filter(
+            // field was not removed, so check its default value
+            oldField => this.doDefaultValuesDiffer(oldField, newFields.find(newField => newField.fieldName === oldField.fieldName)));
+            // find the new fields that have not been added newly anyway or otherwise where the old field had a different default value
+            const addedDefaultValueFields = newFieldsWithDefaultValues
+                .filter(newField => !addedFieldNames.includes(newField.fieldName))
+                .filter(
+            // field was not added newly, so check its default value
+            newField => this.doDefaultValuesDiffer(oldFields.find(oldField => oldField.fieldName === newField.fieldName), newField));
             return {
                 ...baseChangelog(),
                 previousEntity: oldConfig,
@@ -139,7 +155,15 @@ export default class GeneratorBaseEntityChanges extends GeneratorBaseApplication
                 addedRelationships,
                 removedRelationships,
                 relationshipsToRecreateForeignKeysOnly,
+                removedDefaultValueFields,
+                addedDefaultValueFields,
             };
         });
     }
+    hasAnyDefaultValue(field) {
+        return field.defaultValue !== undefined || field.defaultValueComputed;
+    }
+    doDefaultValuesDiffer(field1, field2) {
+        return field1.defaultValue !== field2.defaultValue || field1.defaultValueComputed !== field2.defaultValueComputed;
+    }
 }

package/dist/generators/base-workspaces/internal/deployments.js

@@ -16,13 +16,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as _ from 'lodash-es';
+import { defaults } from 'lodash-es';
 import { applicationOptions, deploymentOptions } from '../../../jdl/index.js';
 import { loadDerivedPlatformConfig, loadPlatformConfig, loadDerivedServerAndPlatformProperties } from '../../server/support/index.js';
 const { OptionNames } = applicationOptions;
 const { Options: DeploymentOptions } = deploymentOptions;
 const { JWT_SECRET_KEY } = OptionNames;
-export function loadDeploymentConfig({ config = _.defaults({}, this.jhipsterConfig, DeploymentOptions.defaults(this.jhipsterConfig.deploymentType)), deployment = this, } = {}) {
+export function loadDeploymentConfig({ config = defaults({}, this.jhipsterConfig, DeploymentOptions.defaults(this.jhipsterConfig.deploymentType)), deployment = this, } = {}) {
     deployment.appsFolders = config.appsFolders;
     deployment.directoryPath = config.directoryPath;
     deployment.clusteredDbApps = config.clusteredDbApps;

package/dist/generators/base-workspaces/internal/docker-dependencies.js

@@ -17,11 +17,11 @@
  * limitations under the License.
  */
 import { dockerContainers as elasticDockerContainer } from '../../generator-constants.js';
-import { dockerPlaceholderGenerator, getDockerfileContainers } from '../../docker/utils.js';
+import { getDockerfileContainers } from '../../docker/utils.js';
 export async function loadDockerDependenciesTask({ context = this } = {}) {
     const dockerfile = this.readTemplate(this.jhipsterTemplatePath('../../server/resources/Dockerfile'));
     context.dockerContainers = this.prepareDependencies({
         ...elasticDockerContainer,
         ...getDockerfileContainers(dockerfile),
-    }, dockerPlaceholderGenerator);
+    }, 'docker');
 }

package/dist/generators/bootstrap/generator.js

@@ -23,9 +23,8 @@ import { createCommitTransform } from 'mem-fs-editor/transform';
 import BaseGenerator from '../base/index.js';
 import { createMultiStepTransform, createPrettierTransform, createForceWriteConfigFilesTransform, autoCrlfTransform, isPrettierConfigFilePath, createSortConfigFilesTransform, createESLintTransform, createRemoveUnusedImportsTransform, } from './support/index.js';
 import { PRETTIER_EXTENSIONS } from '../generator-constants.js';
-import { GENERATOR_BOOTSTRAP, GENERATOR_UPGRADE } from '../generator-list.js';
+import { GENERATOR_UPGRADE } from '../generator-list.js';
 import { PRIORITY_NAMES, QUEUES } from '../base-application/priorities.js';
-import command from './command.js';
 import { loadStoredAppOptions } from '../app/support/index.js';
 const { MULTISTEP_TRANSFORM, PRE_CONFLICTS } = PRIORITY_NAMES;
 const { MULTISTEP_TRANSFORM_QUEUE, PRE_CONFLICTS_QUEUE } = QUEUES;
@@ -48,7 +47,7 @@ export default class BootstrapGenerator extends BaseGenerator {
         this.env.options.nodePackageManager = 'npm';
         this.upgradeCommand = this.options.commandName === GENERATOR_UPGRADE;
         if (!this.fromBlueprint) {
-            await this.composeWithBlueprints(GENERATOR_BOOTSTRAP);
+            await this.composeWithBlueprints();
         }
         if (this.delegateToBlueprint) {
             throw new Error('Only sbs blueprint is supported');
@@ -56,8 +55,8 @@ export default class BootstrapGenerator extends BaseGenerator {
     }
     get initializing() {
         return this.asInitializingTaskGroup({
-            loadOptions() {
-                this.parseJHipsterOptions(command.options, command.configs);
+            async parseCommand() {
+                await this.parseCurrentJHipsterCommand();
             },
             validateBlueprint() {
                 if (this.jhipsterConfig.blueprints && !this.skipChecks) {

package/dist/generators/bootstrap/internal/transform-utils.js

@@ -0,0 +1,4 @@
+export const addLineNumbers = input => input
+    .split('\n')
+    .map((line, index) => `${index + 1}: ${line}`)
+    .join('\n');

package/dist/generators/bootstrap/support/eslint-transform.js

@@ -22,6 +22,7 @@ import { Minimatch } from 'minimatch';
 import { Piscina } from 'piscina';
 import { getPackageRoot } from '../../../lib/index.js';
 import { JS_PRETTIER_EXTENSIONS } from '../../generator-constants.js';
+import { addLineNumbers } from '../internal/transform-utils.js';
 // eslint-disable-next-line import/prefer-default-export
 export const createESLintTransform = function (transformOptions = {}) {
     const { extensions = JS_PRETTIER_EXTENSIONS, ignoreErrors } = transformOptions;
@@ -44,7 +45,7 @@ export const createESLintTransform = function (transformOptions = {}) {
             file.contents = Buffer.from(result);
         }
         if (error) {
-            const errorMessage = `Error parsing file ${file.relative}: ${error} at ${fileContents}`;
+            const errorMessage = `Error parsing file ${file.relative}: ${error} at ${addLineNumbers(fileContents)}`;
             if (!ignoreErrors) {
                 throw new Error(errorMessage);
             }

package/dist/generators/bootstrap/support/java-unused-imports-transform.js

@@ -2,6 +2,7 @@ import { extname } from 'path';
 import { passthrough } from 'p-transform';
 import { isFileStateModified } from 'mem-fs-editor/state';
 import { Piscina } from 'piscina';
+import { addLineNumbers } from '../internal/transform-utils.js';
 // eslint-disable-next-line import/prefer-default-export
 export const createRemoveUnusedImportsTransform = function (options = {}) {
     const { ignoreErrors } = options;
@@ -21,7 +22,7 @@ export const createRemoveUnusedImportsTransform = function (options = {}) {
                     file.contents = Buffer.from(result);
                 }
                 if (error) {
-                    const errorMessage = `Error parsing file ${file.relative}: ${error} at ${fileContents}`;
+                    const errorMessage = `Error parsing file ${file.relative}: ${error} at ${addLineNumbers(fileContents)}`;
                     if (ignoreErrors) {
                         this?.log?.warn?.(errorMessage);
                         return;

package/dist/generators/bootstrap/support/prettier-worker.js

@@ -2,6 +2,7 @@ import prettier from 'prettier';
 import prettierPluginJava from 'prettier-plugin-java';
 import prettierPluginProperties from 'prettier-plugin-properties';
 import prettierPluginPackagejson from 'prettier-plugin-packagejson';
+import { addLineNumbers } from '../internal/transform-utils.js';
 export default async ({ relativeFilePath, filePath, fileContents, prettierOptions, prettierPackageJson, prettierJava, prettierProperties, }) => {
     try {
         const resolvedDestinationFileOptions = await prettier.resolveConfig(relativeFilePath);
@@ -29,10 +30,7 @@ export default async ({ relativeFilePath, filePath, fileContents, prettierOption
         if (fileContents) {
             errorMessage = `Error parsing file ${relativeFilePath}: ${error}
 
-At: ${fileContents
-                .split('\n')
-                .map((value, idx) => `${idx + 1}: ${value}`)
-                .join('\n')}`;
+At: ${addLineNumbers(fileContents)}`;
         }
         else {
             errorMessage = `Unknown prettier error: ${error}`;

package/dist/generators/bootstrap-application/generator.js

@@ -20,7 +20,6 @@ import assert from 'assert';
 import BaseApplicationGenerator from '../base-application/index.js';
 import { validations } from '../../jdl/jhipster/index.js';
 import { stringifyApplicationData, derivedPrimaryKeyProperties, preparePostEntitiesCommonDerivedProperties, preparePostEntityCommonDerivedProperties, } from '../base-application/support/index.js';
-import { GENERATOR_BOOTSTRAP_APPLICATION, GENERATOR_BOOTSTRAP_APPLICATION_CLIENT, GENERATOR_BOOTSTRAP_APPLICATION_SERVER, } from '../generator-list.js';
 import { preparePostEntityServerDerivedProperties } from '../server/support/index.js';
 import { loadStoredAppOptions } from '../app/support/index.js';
 import { JHIPSTER_DOCUMENTATION_ARCHIVE_PATH, JHIPSTER_DOCUMENTATION_URL } from '../generator-constants.js';
@@ -34,13 +33,13 @@ export default class BootstrapApplicationGenerator extends BaseApplicationGenera
     }
     async beforeQueue() {
         if (!this.fromBlueprint) {
-            await this.composeWithBlueprints(GENERATOR_BOOTSTRAP_APPLICATION);
+            await this.composeWithBlueprints();
         }
         if (this.delegateToBlueprint) {
             throw new Error('Only sbs blueprint is supported');
         }
-        await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_CLIENT);
-        await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_SERVER);
+        await this.dependsOnBootstrapApplicationClient();
+        await this.dependsOnBootstrapApplicationServer();
     }
     get preparing() {
         return this.asPreparingTaskGroup({

package/dist/generators/bootstrap-application-base/generator.js

@@ -18,7 +18,7 @@
  */
 import assert from 'assert';
 import os from 'os';
-import * as _ from 'lodash-es';
+import { lowerFirst } from 'lodash-es';
 import chalk from 'chalk';
 import { passthrough } from '@yeoman/transform';
 import { isFileStateModified } from 'mem-fs-editor/state';
@@ -26,14 +26,13 @@ import BaseApplicationGenerator from '../base-application/index.js';
 import { addFakerToEntity, loadEntitiesAnnotations, loadEntitiesOtherSide, stringifyApplicationData, prepareEntity as prepareEntityForTemplates, prepareField as prepareFieldForTemplates, prepareRelationship, } from '../base-application/support/index.js';
 import { createAuthorityEntity, createUserEntity, createUserManagementEntity } from './utils.js';
 import { JAVA_DOCKER_DIR } from '../generator-constants.js';
-import { GENERATOR_BOOTSTRAP, GENERATOR_BOOTSTRAP_APPLICATION_BASE, GENERATOR_COMMON, GENERATOR_PROJECT_NAME } from '../generator-list.js';
+import { GENERATOR_BOOTSTRAP, GENERATOR_COMMON, GENERATOR_PROJECT_NAME } from '../generator-list.js';
 import { packageJson } from '../../lib/index.js';
 import { loadLanguagesConfig } from '../languages/support/index.js';
 import { loadAppConfig, loadDerivedAppConfig, loadStoredAppOptions } from '../app/support/index.js';
 import { exportJDLTransform, importJDLTransform } from './support/index.js';
 import command from './command.js';
 const isWin32 = os.platform() === 'win32';
-const { lowerFirst } = _;
 export default class BootstrapApplicationBase extends BaseApplicationGenerator {
     constructor(args, options, features) {
         super(args, options, { jhipsterBootstrap: false, ...features });
@@ -43,7 +42,7 @@ export default class BootstrapApplicationBase extends BaseApplicationGenerator {
     }
     async beforeQueue() {
         if (!this.fromBlueprint) {
-            await this.composeWithBlueprints(GENERATOR_BOOTSTRAP_APPLICATION_BASE);
+            await this.composeWithBlueprints();
         }
         if (this.delegateToBlueprint) {
             throw new Error('Only sbs blueprint is supported');
@@ -89,13 +88,17 @@ export default class BootstrapApplicationBase extends BaseApplicationGenerator {
     }
     get loading() {
         return this.asLoadingTaskGroup({
-            loadApplication({ application, control }) {
+            loadApplication({ application, control, applicationDefaults }) {
                 loadAppConfig({
                     config: this.jhipsterConfigWithDefaults,
                     application,
                     useVersionPlaceholders: this.useVersionPlaceholders,
                 });
                 loadLanguagesConfig({ application, config: this.jhipsterConfigWithDefaults, control });
+                applicationDefaults({
+                    backendType: this.jhipsterConfig.backendType ?? 'Java',
+                    syncUserWithIdp: this.jhipsterConfig.syncUserWithIdp,
+                });
             },
             loadNodeDependencies({ application }) {
                 this.loadNodeDependencies(application.nodeDependencies, {
@@ -115,10 +118,47 @@ export default class BootstrapApplicationBase extends BaseApplicationGenerator {
             prepareApplication({ application, applicationDefaults }) {
                 loadDerivedAppConfig({ application });
                 applicationDefaults({
+                    __override__: false,
                     nodePackageManager: 'npm',
                     dockerServicesDir: JAVA_DOCKER_DIR,
                     // TODO drop clientPackageManager
                     clientPackageManager: ({ nodePackageManager }) => nodePackageManager,
+                    hipsterName: 'Java Hipster',
+                    hipsterProductName: 'JHipster',
+                    hipsterHomePageProductName: 'JHipster',
+                    hipsterStackOverflowProductName: 'JHipster',
+                    hipsterBugTrackerProductName: 'JHipster',
+                    hipsterChatProductName: 'JHipster',
+                    hipsterTwitterUsername: '@jhipster',
+                    hipsterDocumentationLink: 'https://www.jhipster.tech/',
+                    hipsterTwitterLink: 'https://twitter.com/jhipster',
+                    hipsterProjectLink: 'https://github.com/jhipster/generator-jhipster',
+                    hipsterStackoverflowLink: 'https://stackoverflow.com/tags/jhipster/info',
+                    hipsterBugTrackerLink: 'https://github.com/jhipster/generator-jhipster/issues?state=open',
+                    hipsterChatLink: 'https://gitter.im/jhipster/generator-jhipster',
+                    backendTypeSpringBoot: ({ backendType }) => backendType === 'Java',
+                    backendTypeJavaAny: ({ backendTypeSpringBoot }) => backendTypeSpringBoot,
+                });
+            },
+            syncUserWithIdp({ application, applicationDefaults }) {
+                if (!application.backendTypeSpringBoot)
+                    return;
+                if (application.syncUserWithIdp === undefined && application.authenticationType === 'oauth2') {
+                    applicationDefaults({
+                        __override__: false,
+                        syncUserWithIdp: data => data.databaseType !== 'no' &&
+                            (data.applicationType === 'gateway' ||
+                                this.getExistingEntities().some(entity => (entity.definition.relationships ?? []).some(relationship => relationship.otherEntityName.toLowerCase() === 'user'))),
+                    });
+                }
+                else if (application.syncUserWithIdp && application.authenticationType !== 'oauth2') {
+                    throw new Error('syncUserWithIdp is only supported with oauth2 authenticationType');
+                }
+            },
+            userManagement({ applicationDefaults }) {
+                applicationDefaults({
+                    generateBuiltInUserEntity: ({ generateUserManagement, syncUserWithIdp }) => generateUserManagement || syncUserWithIdp,
+                    generateBuiltInAuthorityEntity: ({ generateBuiltInUserEntity, databaseType }) => generateBuiltInUserEntity && databaseType !== 'cassandra',
                 });
             },
         });
@@ -286,7 +326,7 @@ export default class BootstrapApplicationBase extends BaseApplicationGenerator {
         });
     }
     get [BaseApplicationGenerator.POST_PREPARING_EACH_ENTITY]() {
-        return this.asPostPreparingEachEntityTaskGroup(this.delegateTasksToBlueprint(() => this.postPreparingEachEntity));
+        return this.delegateTasksToBlueprint(() => this.postPreparingEachEntity);
     }
     get default() {
         return this.asDefaultTaskGroup({