generator-jhipster 8.2.1 → 8.4.0

package/dist/generators/liquibase/generator.js

@@ -17,9 +17,8 @@
  * limitations under the License.
  */
 import fs from 'fs';
-import * as _ from 'lodash-es';
+import { escape, min } from 'lodash-es';
 import BaseEntityChangesGenerator from '../base-entity-changes/index.js';
-import { GENERATOR_LIQUIBASE, GENERATOR_BOOTSTRAP_APPLICATION_SERVER } from '../generator-list.js';
 import { liquibaseFiles } from './files.js';
 import { prepareField as prepareFieldForLiquibase, postPrepareEntity, prepareRelationshipForLiquibase, liquibaseComment, } from './support/index.js';
 import { getFKConstraintName, getUXConstraintName, prepareEntity as prepareEntityForServer } from '../server/support/index.js';
@@ -29,7 +28,6 @@ import { addLiquibaseChangelogCallback, addLiquibaseConstraintsChangelogCallback
 import { prepareSqlApplicationProperties } from '../spring-data-relational/support/index.js';
 import { addEntityFiles, updateEntityFiles, updateConstraintsFiles, updateMigrateFiles, fakeFiles } from './changelog-files.js';
 import { fieldTypes } from '../../jdl/jhipster/index.js';
-import command from './command.js';
 const { CommonDBTypes: { LONG: TYPE_LONG, INTEGER: TYPE_INTEGER }, } = fieldTypes;
 export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
     recreateInitialChangelog;
@@ -49,21 +47,21 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
     }
     async beforeQueue() {
         if (!this.fromBlueprint) {
-            await this.composeWithBlueprints(GENERATOR_LIQUIBASE);
+            await this.composeWithBlueprints();
         }
         if (!this.delegateToBlueprint) {
-            await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_SERVER);
+            await this.dependsOnBootstrapApplicationServer();
         }
     }
     get initializing() {
         return this.asInitializingTaskGroup({
-            loadConfig() {
-                this.parseJHipsterOptions(command.options);
+            async parseCommand() {
+                await this.parseCurrentJHipsterCommand();
             },
         });
     }
     get [BaseEntityChangesGenerator.INITIALIZING]() {
-        return this.asInitializingTaskGroup(this.delegateTasksToBlueprint(() => this.initializing));
+        return this.delegateTasksToBlueprint(() => this.initializing);
     }
     get preparing() {
         return this.asPreparingTaskGroup({
@@ -99,6 +97,11 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
                     prepareFieldForLiquibase(entity, field);
                 }
             },
+            validateConsistencyOfField({ entity, field }) {
+                if (field.columnRequired && field.liquibaseDefaultValueAttributeValue) {
+                    this.handleCheckFailure(`The field ${field.fieldName} in entity ${entity.name} has both columnRequired and a defaultValue, this can lead to unexpected behaviors.`);
+                }
+            },
         });
     }
     get [BaseEntityChangesGenerator.PREPARING_EACH_ENTITY_FIELD]() {
@@ -164,15 +167,24 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
                 const changes = entityChanges.filter(databaseChangelog => entitiesToWrite.length === 0 || entitiesToWrite.includes(databaseChangelog.entityName));
                 for (const databaseChangelog of changes) {
                     if (databaseChangelog.newEntity) {
-                        this.databaseChangelogs.push(this.prepareChangelog({ databaseChangelog, application }));
+                        this.databaseChangelogs.push(this.prepareChangelog({
+                            databaseChangelog: {
+                                ...databaseChangelog,
+                                changelogData: { ...databaseChangelog.changelogData },
+                            },
+                            application,
+                        }));
                     }
                     else if (databaseChangelog.addedFields.length > 0 || databaseChangelog.removedFields.length > 0) {
                         this.databaseChangelogs.push(this.prepareChangelog({
                             databaseChangelog: {
                                 ...databaseChangelog,
+                                changelogData: { ...databaseChangelog.changelogData },
                                 fieldChangelog: true,
                                 addedRelationships: [],
                                 removedRelationships: [],
+                                removedDefaultValueFields: [],
+                                addedDefaultValueFields: [],
                                 relationshipsToRecreateForeignKeysOnly: [],
                             },
                             application,
@@ -182,10 +194,14 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
                 // Relationships needs to be added later to make sure every related field is already added.
                 for (const databaseChangelog of changes) {
                     if (databaseChangelog.incremental &&
-                        (databaseChangelog.addedRelationships.length > 0 || databaseChangelog.removedRelationships.length > 0)) {
+                        (databaseChangelog.addedRelationships.length > 0 ||
+                            databaseChangelog.removedRelationships.length > 0 ||
+                            databaseChangelog.removedDefaultValueFields.length > 0 ||
+                            databaseChangelog.addedDefaultValueFields.length > 0)) {
                         this.databaseChangelogs.push(this.prepareChangelog({
                             databaseChangelog: {
                                 ...databaseChangelog,
+                                changelogData: { ...databaseChangelog.changelogData },
                                 relationshipChangelog: true,
                                 addedFields: [],
                                 removedFields: [],
@@ -268,36 +284,58 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
                 if (!application.javaDependencies) {
                     throw new Error('Some application fields are be mandatory');
                 }
+                const { javaDependencies } = application;
+                const checkProperty = (property) => {
+                    if (!source.hasJavaManagedProperty?.(property) && !source.hasJavaProperty?.(property)) {
+                        const message = `${property} is required by maven-liquibase-plugin, make sure to add it to your pom.xml`;
+                        if (this.skipChecks) {
+                            this.log.warn(message);
+                        }
+                        else {
+                            throw new Error(message);
+                        }
+                    }
+                };
+                const { 'jakarta-validation': validationVersion, h2: h2Version, liquibase: liquibaseVersion } = javaDependencies;
                 const applicationAny = application;
                 const databaseTypeProfile = applicationAny.devDatabaseTypeH2Any ? 'prod' : undefined;
                 let liquibasePluginHibernateDialect;
                 let liquibasePluginJdbcDriver;
+                const mavenProperties = [];
                 if (applicationAny.devDatabaseTypeH2Any) {
                     // eslint-disable-next-line no-template-curly-in-string
                     liquibasePluginHibernateDialect = '${liquibase-plugin.hibernate-dialect}';
                     // eslint-disable-next-line no-template-curly-in-string
                     liquibasePluginJdbcDriver = '${liquibase-plugin.driver}';
-                    source.addMavenDefinition?.({
-                        properties: [
-                            { property: 'liquibase-plugin.hibernate-dialect' },
-                            { property: 'liquibase-plugin.driver' },
-                            { property: 'h2.version', value: application.springBootDependencies.h2 },
-                            { inProfile: 'dev', property: 'liquibase-plugin.hibernate-dialect', value: applicationAny.devHibernateDialect },
-                            { inProfile: 'prod', property: 'liquibase-plugin.hibernate-dialect', value: applicationAny.prodHibernateDialect },
-                            { inProfile: 'dev', property: 'liquibase-plugin.driver', value: applicationAny.devJdbcDriver },
-                            { inProfile: 'prod', property: 'liquibase-plugin.driver', value: applicationAny.prodJdbcDriver },
-                        ],
-                    });
+                    if (h2Version) {
+                        mavenProperties.push({ property: 'h2.version', value: h2Version });
+                    }
+                    else {
+                        checkProperty('h2.version');
+                    }
+                    mavenProperties.push({ property: 'liquibase-plugin.hibernate-dialect' }, { property: 'liquibase-plugin.driver' }, { inProfile: 'dev', property: 'liquibase-plugin.hibernate-dialect', value: applicationAny.devHibernateDialect }, { inProfile: 'prod', property: 'liquibase-plugin.hibernate-dialect', value: applicationAny.prodHibernateDialect }, { inProfile: 'dev', property: 'liquibase-plugin.driver', value: applicationAny.devJdbcDriver }, { inProfile: 'prod', property: 'liquibase-plugin.driver', value: applicationAny.prodJdbcDriver });
                 }
                 else {
                     liquibasePluginHibernateDialect = applicationAny.prodHibernateDialect;
                     liquibasePluginJdbcDriver = applicationAny.prodJdbcDriver;
                 }
+                if (validationVersion) {
+                    mavenProperties.push({ property: 'jakarta-validation.version', value: validationVersion });
+                }
+                else {
+                    checkProperty('jakarta-validation.version');
+                }
+                if (liquibaseVersion) {
+                    mavenProperties.push({ property: 'liquibase.version', value: liquibaseVersion });
+                }
+                else {
+                    checkProperty('liquibase.version');
+                }
                 source.addMavenDefinition?.({
                     properties: [
+                        ...mavenProperties,
                         { inProfile: 'no-liquibase', property: 'profile.no-liquibase', value: ',no-liquibase' },
                         { property: 'profile.no-liquibase' },
-                        { property: 'liquibase.version', value: application.springBootDependencies.liquibase },
                         { property: 'liquibase-plugin.url' },
                         { property: 'liquibase-plugin.username' },
                         { property: 'liquibase-plugin.password' },
@@ -384,18 +422,33 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
                 if (!application.javaDependencies) {
                     throw new Error('Some application fields are be mandatory');
                 }
+                const { liquibase: liquibaseVersion, 'gradle-liquibase': gradleLiquibaseVersion } = application.javaDependencies;
+                if (!liquibaseVersion) {
+                    this.log.warn('liquibaseVersion is required by gradle-liquibase-plugin, make sure to add it to your dependencies');
+                }
+                else {
+                    source.addGradleProperty?.({ property: 'liquibaseVersion', value: liquibaseVersion });
+                }
                 source.addGradleProperty?.({ property: 'liquibaseTaskPrefix', value: 'liquibase' });
-                source.addGradleProperty?.({ property: 'liquibasePluginVersion', value: application.javaDependencies['gradle-liquibase'] });
-                source.addGradleProperty?.({ property: 'liquibaseVersion', value: application.springBootDependencies.liquibase });
+                source.addGradleProperty?.({ property: 'liquibasePluginVersion', value: gradleLiquibaseVersion });
                 source.applyFromGradle?.({ script: 'gradle/liquibase.gradle' });
                 source.addGradlePlugin?.({ id: 'org.liquibase.gradle' });
                 // eslint-disable-next-line no-template-curly-in-string
                 source.addGradlePluginManagement?.({ id: 'org.liquibase.gradle', version: '${liquibasePluginVersion}' });
+                if (application.databaseTypeSql && !application.reactive) {
+                    source.addGradleDependency?.({
+                        scope: 'liquibaseRuntime',
+                        groupId: 'org.liquibase.ext',
+                        artifactId: 'liquibase-hibernate6',
+                        // eslint-disable-next-line no-template-curly-in-string
+                        version: liquibaseVersion ? '${liquibaseVersion}' : "${dependencyManagement.importedProperties['liquibase.version']}",
+                    }, { gradleFile: 'gradle/liquibase.gradle' });
+                }
             },
         });
     }
     get [BaseEntityChangesGenerator.POST_WRITING]() {
-        return this.asPostWritingTaskGroup(this.delegateTasksToBlueprint(() => this.postWriting));
+        return this.delegateTasksToBlueprint(() => this.postWriting);
     }
     get postWritingEntities() {
         return this.asPostWritingEntitiesTaskGroup({
@@ -447,7 +500,7 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
      * Write files for updated entities.
      */
     _writeUpdateFiles({ context: writeContext, changelogData }) {
-        const { addedFields, allFields, removedFields, addedRelationships, removedRelationships, hasFieldConstraint, hasRelationshipConstraint, shouldWriteAnyRelationship, relationshipsToRecreateForeignKeysOnly, } = changelogData;
+        const { addedFields, allFields, removedFields, addedRelationships, removedRelationships, hasFieldConstraint, hasRelationshipConstraint, shouldWriteAnyRelationship, relationshipsToRecreateForeignKeysOnly, hasDefaultValueChange, removedDefaultValueFields, addedDefaultValueFields, } = changelogData;
         const context = {
             ...writeContext,
             skipFakeData: changelogData.skipFakeData,
@@ -462,29 +515,45 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
             hasRelationshipConstraint,
             shouldWriteAnyRelationship,
             relationshipsToRecreateForeignKeysOnly,
+            hasDefaultValueChange,
+            removedDefaultValueFields,
+            addedDefaultValueFields,
         };
         const promises = [];
-        promises.push(this.writeFiles({ sections: updateEntityFiles, context }));
-        if (!changelogData.skipFakeData && (changelogData.addedFields.length > 0 || shouldWriteAnyRelationship)) {
+        if (this._isBasicEntityUpdate(changelogData)) {
+            promises.push(this.writeFiles({ sections: updateEntityFiles, context }));
+        }
+        if (this._requiresWritingFakeData(changelogData)) {
             promises.push(this.writeFiles({ sections: fakeFiles, context }));
             promises.push(this.writeFiles({ sections: updateMigrateFiles, context }));
         }
-        if (hasFieldConstraint || shouldWriteAnyRelationship) {
+        if (this._requiresConstraintUpdates(changelogData)) {
             promises.push(this.writeFiles({ sections: updateConstraintsFiles, context }));
         }
         return Promise.all(promises);
     }
+    _requiresConstraintUpdates(changelogData) {
+        return changelogData.hasFieldConstraint || changelogData.addedRelationships.length > 0 || changelogData.hasDefaultValueChange;
+    }
+    _isBasicEntityUpdate(changelogData) {
+        return changelogData.addedFields.length > 0 || changelogData.removedFields.length > 0 || changelogData.shouldWriteAnyRelationship;
+    }
+    _requiresWritingFakeData(changelogData) {
+        return !changelogData.skipFakeData && (changelogData.addedFields.length || changelogData.addedRelationships.length);
+    }
     /**
      * Write files for updated entities.
      */
     _addUpdateFilesReferences({ entity, databaseChangelog, changelogData, source }) {
-        source.addLiquibaseIncrementalChangelog({ changelogName: `${databaseChangelog.changelogDate}_updated_entity_${entity.entityClass}` });
-        if (!changelogData.skipFakeData && (changelogData.addedFields.length > 0 || changelogData.shouldWriteAnyRelationship)) {
+        if (this._isBasicEntityUpdate(changelogData)) {
+            source.addLiquibaseIncrementalChangelog({ changelogName: `${databaseChangelog.changelogDate}_updated_entity_${entity.entityClass}` });
+        }
+        if (this._requiresWritingFakeData(changelogData)) {
             source.addLiquibaseIncrementalChangelog({
                 changelogName: `${databaseChangelog.changelogDate}_updated_entity_migrate_${entity.entityClass}`,
             });
         }
-        if (changelogData.hasFieldConstraint || changelogData.shouldWriteAnyRelationship) {
+        if (this._requiresConstraintUpdates(changelogData)) {
             source.addLiquibaseIncrementalChangelog({
                 changelogName: `${databaseChangelog.changelogDate}_updated_entity_constraints_${entity.entityClass}`,
             });
@@ -501,6 +570,19 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
     formatAsLiquibaseRemarks(text, addRemarksTag = false) {
         return liquibaseComment(text, addRemarksTag);
     }
+    /**
+     * @private
+     * Create the fitting liquibase default value attribute for a field.
+     * @param field
+     * @param leadingWhitespace
+     * @returns
+     */
+    createDefaultValueLiquibaseAttribute(field, leadingWhitespace = false) {
+        if (field.liquibaseDefaultValueAttributeValue === undefined) {
+            return '';
+        }
+        return `${leadingWhitespace ? ' ' : ''}${field.liquibaseDefaultValueAttributeName}="${escape(field.liquibaseDefaultValueAttributeValue)}"`;
+    }
     prepareChangelog({ databaseChangelog, application }) {
         if (!databaseChangelog.changelogDate) {
             databaseChangelog.changelogDate = this.dateFormatForLiquibase();
@@ -527,7 +609,7 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
         Object.defineProperty(entity, 'fakeDataCount', {
             get: () => {
                 const uniqueRelationships = entity.relationships.filter(rel => rel.unique && (rel.columnRequired || rel.id));
-                return _.min([entity.liquibaseFakeData.length, ...uniqueRelationships.map(rel => rel.otherEntity.fakeDataCount)]);
+                return min([entity.liquibaseFakeData.length, ...uniqueRelationships.map(rel => rel.otherEntity.fakeDataCount)]);
             },
             configurable: true,
         });
@@ -567,6 +649,8 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
             entityChanges.addedRelationships = databaseChangelog.addedRelationships;
             entityChanges.removedRelationships = databaseChangelog.removedRelationships;
             entityChanges.relationshipsToRecreateForeignKeysOnly = databaseChangelog.relationshipsToRecreateForeignKeysOnly;
+            entityChanges.removedDefaultValueFields = databaseChangelog.removedDefaultValueFields;
+            entityChanges.addedDefaultValueFields = databaseChangelog.addedDefaultValueFields;
         }
         /* Required by the templates */
         databaseChangelog.writeContext = {
@@ -588,11 +672,17 @@ export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
             entityChanges.addedFields.length > 0 ||
                 entityChanges.removedFields.length > 0 ||
                 entityChanges.addedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable) ||
-                entityChanges.removedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable);
+                entityChanges.removedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable) ||
+                entityChanges.addedDefaultValueFields.length > 0 ||
+                entityChanges.removedDefaultValueFields.length > 0;
         if (entityChanges.requiresUpdateChangelogs) {
-            entityChanges.hasFieldConstraint = entityChanges.addedFields.some(field => field.unique || !field.nullable);
+            entityChanges.hasFieldConstraint = entityChanges.addedFields.some(field => field.unique || (field.columnRequired && !field.liquibaseDefaultValueAttributeValue) || field.shouldCreateContentType);
+            entityChanges.hasDefaultValueChange =
+                entityChanges.addedDefaultValueFields.length > 0 || entityChanges.removedDefaultValueFields.length > 0;
             entityChanges.hasRelationshipConstraint = entityChanges.addedRelationships.some(relationship => (relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable) && (relationship.unique || !relationship.nullable));
-            entityChanges.shouldWriteAnyRelationship = entityChanges.addedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable);
+            entityChanges.shouldWriteAnyRelationship =
+                entityChanges.addedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable) ||
+                    entityChanges.removedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable);
         }
         return databaseChangelog;
     }

package/dist/generators/liquibase/support/maven-plugin.js

@@ -25,10 +25,16 @@ export default function mavenPluginContent({ backendTypeSpringBoot, reactive, pa
         <groupId>org.liquibase.ext</groupId>
         <artifactId>liquibase-hibernate6</artifactId>
         <version>\${liquibase.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>jakarta.validation</groupId>
+        <artifactId>jakarta.validation-api</artifactId>
+        <version>\${jakarta-validation.version}</version>
       </dependency>${backendTypeSpringBoot ? `
       <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-jpa</artifactId>
+        <version>\${spring-boot.version}</version>
       </dependency>` : ''}${devDatabaseTypeH2Any ? `
       <dependency>
         <groupId>com.h2database</groupId>

package/dist/generators/liquibase/support/prepare-field.js

@@ -114,11 +114,26 @@ export default function prepareField(entity, field) {
     mutateData(field, {
         __override__: false,
         columnType: data => parseLiquibaseColumnType(entity, data),
-        shouldDropDefaultValue: data => data.fieldType === ZONED_DATE_TIME || data.fieldType === INSTANT,
+        liquibaseDefaultValueAttributeValue: ({ defaultValue, defaultValueComputed }) => defaultValueComputed ?? defaultValue?.toString(),
+        liquibaseDefaultValueAttributeName: ({ defaultValueComputed, liquibaseDefaultValueAttributeValue }) => {
+            if (liquibaseDefaultValueAttributeValue === undefined)
+                return undefined;
+            if (defaultValueComputed)
+                return 'defaultValueComputed';
+            if (field.fieldTypeNumeric)
+                return 'defaultValueNumeric';
+            if (field.fieldTypeDateTime)
+                return 'defaultValueDate';
+            if (field.fieldTypeBoolean)
+                return 'defaultValueBoolean';
+            return 'defaultValue';
+        },
+        shouldDropDefaultValue: data => !data.liquibaseDefaultValueAttributeValue && (data.fieldType === ZONED_DATE_TIME || data.fieldType === INSTANT),
         shouldCreateContentType: data => data.fieldType === BYTES && data.fieldTypeBlobContent !== TEXT,
         columnRequired: data => data.nullable === false || (data.fieldValidate === true && data.fieldValidateRules.includes('required')),
         nullable: data => !data.columnRequired,
         loadColumnType: data => parseLiquibaseLoadColumnType(entity, data),
+        liquibaseGenerateFakeData: true,
     });
     return field;
 }

package/dist/generators/liquibase/support/relationship.js

@@ -65,6 +65,7 @@ export function prepareRelationshipForLiquibase(entity, relationship) {
         __override__: false,
         columnDataType: data => data.otherEntity.columnType,
         columnRequired: data => data.nullable === false || data.relationshipRequired,
+        liquibaseGenerateFakeData: data => data.columnRequired && data.persistableRelationship && !data.collection,
     });
     return relationship;
 }

package/dist/generators/liquibase/templates/gradle/liquibase.gradle.ejs

@@ -7,10 +7,6 @@ dependencies {
   liquibaseRuntime "org.liquibase:liquibase-core"
   // Dependency required to parse options. Refer to https://github.com/liquibase/liquibase-gradle-plugin/tree/Release_2.2.0#news.
   liquibaseRuntime "info.picocli:picocli:<%- javaDependencies.picocli %>"
-<%_ if (databaseTypeSql && !reactive) { _%>
-
-  liquibaseRuntime "org.liquibase.ext:liquibase-hibernate6:${liquibaseVersion}"
-<%_ } _%>
 <%_ if (databaseTypeSql) { _%>
   <%_ if (prodDatabaseType !== devDatabaseType) { _%>
   if (project.hasProperty("prod") || project.hasProperty("gae")) {
@@ -26,7 +22,7 @@ dependencies {
   <%_ } _%>
   <%_ if (prodDatabaseTypeMssql) { _%>
   liquibaseRuntime "com.microsoft.sqlserver:mssql-jdbc"
-  liquibaseRuntime "org.liquibase.ext:liquibase-mssql:${liquibaseVersion}"
+  liquibaseRuntime "org.liquibase.ext:liquibase-mssql:${dependencyManagement.importedProperties['liquibase.version']}"
   <%_ } _%>
   <%_ if (prodDatabaseTypeOracle) { _%>
   liquibaseRuntime "com.oracle.database.jdbc:ojdbc8"
@@ -37,12 +33,13 @@ dependencies {
 <%_ } else if (databaseTypeNeo4j) { _%>
   // Exclude current neo4j driver and use the one provided by spring-data
   // See: https://github.com/jhipster/generator-jhipster/pull/24241
-  implementation ("org.liquibase.ext:liquibase-neo4j:${liquibaseVersion}") {
+  implementation ("org.liquibase.ext:liquibase-neo4j:${dependencyManagement.importedProperties['liquibase.version']}") {
     exclude group: "org.neo4j.driver", module: "neo4j-java-driver"
     exclude group: "org.slf4j", module: "*"
   }
   implementation "org.springframework:spring-jdbc"
 <%_ } _%>
+  // jhipster-needle-gradle-dependency - JHipster will add additional dependencies here
 }
 
 project.ext.diffChangelogFile = "<%= SERVER_MAIN_RES_DIR %>config/liquibase/changelog/" + new Date().format("yyyyMMddHHmmss") + "_changelog.xml"

package/dist/generators/liquibase/templates/src/main/resources/config/liquibase/changelog/added_entity.xml.ejs

@@ -30,7 +30,7 @@
     <changeSet id="<%= changelogDate %>-1" author="jhipster">
         <createTable tableName="<%= entity.entityTableName %>"<%- this.formatAsLiquibaseRemarks(entity.documentation, true) %>>
 <%_ for (field of fields) { _%>
-            <column name="<%= field.columnName %>" type="<%= field.columnType %>"<%- this.formatAsLiquibaseRemarks(field.documentation, true) %><% if (field.id && field.liquibaseAutoIncrement) { %> autoIncrement="true" startWith="1500"<%_ } %>>
+            <column name="<%= field.columnName %>" type="<%= field.columnType %>"<%- this.createDefaultValueLiquibaseAttribute(field, true) -%><%- this.formatAsLiquibaseRemarks(field.documentation, true) %><% if (field.id && field.liquibaseAutoIncrement) { %> autoIncrement="true" startWith="1500"<%_ } %>>
     <%_ if (field.id) { _%>
                 <constraints primaryKey="true" nullable="false"/>
     <%_ } else if (field.unique) { _%>

package/dist/generators/liquibase/templates/src/main/resources/config/liquibase/changelog/updated_entity.xml.ejs

@@ -25,15 +25,15 @@
     <changeSet id="<%= changelogDate %>-1-add-columns" author="jhipster">
         <addColumn tableName="<%= entity.entityTableName %>">
     <%_ for (field of addedFields) { _%>
-            <column name="<%= field.columnName %>" type="<%= field.columnType %>"<%- this.formatAsLiquibaseRemarks(field.documentation, true) %>/>
+            <column name="<%= field.columnName %>" type="<%= field.columnType %>"<%- this.createDefaultValueLiquibaseAttribute(field, true) -%><%- this.formatAsLiquibaseRemarks(field.documentation, true) %>/>
         <%_ if (field.shouldCreateContentType) { _%>
             <column name="<%= field.columnName %>_content_type" type="varchar(255)"/>
         <%_ }
     } // End for (field of addedFields) _%>
         </addColumn>
     <%_ for (field of addedFields) {
-        if (field.fieldType === 'ZonedDateTime' || field.fieldType === 'Instant') { _%>
-        <dropDefaultValue tableName="<%= entity.entityTableName %>" columnName="<%= field.columnName %>" columnDataType="datetime"/>
+        if (field.shouldDropDefaultValue) { _%>
+        <dropDefaultValue tableName="<%= entity.entityTableName %>" columnName="<%= field.columnName %>" columnDataType="${datetimeType}"/>
         <%_ } _%>
     <%_ } _%>
     </changeSet>

package/dist/generators/liquibase/templates/src/main/resources/config/liquibase/changelog/updated_entity_constraints.xml.ejs

@@ -48,6 +48,31 @@ if (hasFieldConstraint) { _%>
     } _%>
     </changeSet>
 <% } _%>
+<%_ if (removedDefaultValueFields && removedDefaultValueFields.length) { _%>
+    <!--
+        Removed the default value for the fields for entity <%= entityClass %>.
+    -->
+    <changeSet id="<%= changelogDate %>-fields-remove-default-value" author="jhipster">
+    <%_ for (field of removedDefaultValueFields) { _%>
+        <dropDefaultValue tableName="<%= entityTableName %>"
+            columnName="<%= field.columnName %>"
+            columnDataType="<%= field.columnType %>"/>
+    <%_ } _%>
+    </changeSet>
+<% } _%>
+<%_ if (addedDefaultValueFields && addedDefaultValueFields.length) { _%>
+    <!--
+        Added the default value for the fields for entity <%= entityClass %>.
+    -->
+    <changeSet id="<%= changelogDate %>-fields-add-default-value" author="jhipster">
+    <%_ for (field of addedDefaultValueFields) { _%>
+        <addDefaultValue tableName="<%= entityTableName %>"
+            columnName="<%= field.columnName %>"
+            columnDataType="<%= field.columnType %>"
+            <%- this.createDefaultValueLiquibaseAttribute(field) -%>/>
+    <%_ } _%>
+    </changeSet>
+<% } _%>
 <%_ if (hasRelationshipConstraint) { _%>
 
     <!--
@@ -74,7 +99,7 @@ if (hasFieldConstraint) { _%>
      } _%>
     </changeSet>
 <%_ } _%>
-<%_ if (shouldWriteAnyRelationship) { %>
+<%_ if (addedRelationships && addedRelationships.length) { %>
 
     <!--
         Added the relationship constraints for entity <%= entityClass %>.

package/dist/generators/liquibase/templates/src/main/resources/config/liquibase/fake-data/table_entity.csv.ejs

@@ -21,14 +21,14 @@ let table = [];
 
 // Generate CSV header
 let header = [];
-const fieldsToGenerate = [...allFields.filter(f => f.id), ...fields.filter(f => !f.id)];
+const fieldsToGenerate = [...allFields.filter(f => f.id), ...fields.filter(f => !f.id)].filter(field => field.liquibaseGenerateFakeData);
 for (field of fieldsToGenerate) {
   header.push(field.columnName);
   if (field.shouldCreateContentType) {
     header.push(field.columnName + '_content_type');
   }
 }
-for (relationship of relationships.filter(relationship => relationship.columnRequired && relationship.persistableRelationship && !relationship.collection)) {
+for (relationship of relationships.filter(relationship => relationship.liquibaseGenerateFakeData)) {
   const { joinColumnNames } = relationship;
   header.push(joinColumnNames[0]);
 }
@@ -57,7 +57,7 @@ for (lineNb = 0; lineNb < entity.fakeDataCount; lineNb++) {
     }
   }
 
-  for (relationship of relationships.filter(relationship => relationship.columnRequired && relationship.persistableRelationship && !relationship.collection)) {
+  for (relationship of relationships.filter(relationship => relationship.liquibaseGenerateFakeData)) {
     const relationshipType = relationship.relationshipType;
     const otherLiquibaseFakeData = relationship.otherEntity.liquibaseFakeData;
     let relationshipRow = lineNb;

package/dist/generators/maven/generator.js

@@ -19,7 +19,6 @@
 /* eslint-disable consistent-return */
 import assert from 'assert/strict';
 import BaseApplicationGenerator from '../base-application/index.js';
-import { GENERATOR_MAVEN, GENERATOR_BOOTSTRAP_APPLICATION_SERVER } from '../generator-list.js';
 import files from './files.js';
 import { MAVEN } from './constants.js';
 import cleanupOldServerFilesTask from './cleanup.js';
@@ -28,10 +27,10 @@ export default class MavenGenerator extends BaseApplicationGenerator {
     pomStorage;
     async beforeQueue() {
         if (!this.fromBlueprint) {
-            await this.composeWithBlueprints(GENERATOR_MAVEN);
+            await this.composeWithBlueprints();
         }
         if (!this.delegateToBlueprint) {
-            await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_SERVER);
+            await this.dependsOnBootstrapApplicationServer();
         }
     }
     get initializing() {
@@ -63,7 +62,8 @@ export default class MavenGenerator extends BaseApplicationGenerator {
             async verify({ application }) {
                 assert.equal(application.buildTool, MAVEN);
             },
-            addSourceNeddles({ source }) {
+            addSourceNeddles({ application, source }) {
+                const { javaProperties } = application;
                 function createForEach(callback) {
                     return (arg) => {
                         const argArray = Array.isArray(arg) ? arg : [arg];
@@ -80,7 +80,13 @@ export default class MavenGenerator extends BaseApplicationGenerator {
                 source.addMavenPluginManagement = createForEach(plugin => this.pomStorage.addPluginManagement(plugin));
                 source.addMavenPluginRepository = createForEach(repository => this.pomStorage.addPluginRepository(repository));
                 source.addMavenProfile = createForEach(profile => this.pomStorage.addProfile(profile));
-                source.addMavenProperty = createForEach(property => this.pomStorage.addProperty(property));
+                source.addMavenProperty = properties => {
+                    properties = Array.isArray(properties) ? properties : [properties];
+                    for (const property of properties) {
+                        javaProperties[property.property] = property.value;
+                        this.pomStorage.addProperty(property);
+                    }
+                };
                 source.addMavenRepository = createForEach(repository => this.pomStorage.addRepository(repository));
                 source.addMavenDefinition = definition => {
                     // profiles should be added first due to inProfile
@@ -92,7 +98,9 @@ export default class MavenGenerator extends BaseApplicationGenerator {
                     definition.distributionManagement?.forEach(distribution => this.pomStorage.addDistributionManagement(distribution));
                     definition.plugins?.forEach(plugin => this.pomStorage.addPlugin(plugin));
                     definition.pluginRepositories?.forEach(repository => this.pomStorage.addPluginRepository(repository));
-                    definition.properties?.forEach(property => this.pomStorage.addProperty(property));
+                    if (definition.properties) {
+                        source.addMavenProperty(definition.properties);
+                    }
                     definition.repositories?.forEach(repository => this.pomStorage.addRepository(repository));
                     definition.annotationProcessors?.forEach(annotation => this.pomStorage.addAnnotationProcessor(annotation));
                 };

package/dist/generators/maven/generators/code-quality/command.js

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