generator-jhipster 8.0.0-beta.2 → 8.0.0-beta.3

package/dist/generators/liquibase/generator.mjs

@@ -17,23 +17,23 @@
  * limitations under the License.
  */
 import fs from 'fs';
-import BaseApplicationGenerator from '../base-application/index.mjs';
-import { GENERATOR_LIQUIBASE, GENERATOR_LIQUIBASE_CHANGELOGS, GENERATOR_BOOTSTRAP_APPLICATION_SERVER } from '../generator-list.mjs';
+import _ from 'lodash';
+import BaseEntityChangesGenerator from '../base-entity-changes/index.mjs';
+import { GENERATOR_LIQUIBASE, GENERATOR_BOOTSTRAP_APPLICATION_SERVER } from '../generator-list.mjs';
 import { liquibaseFiles } from './files.mjs';
-import { prepareField as prepareFieldForLiquibase, postPrepareEntity, relationshipEquals, relationshipNeedsForeignKeyRecreationOnly, prepareRelationshipForLiquibase, } from './support/index.mjs';
-import { addEntitiesOtherRelationships, prepareEntity as prepareEntityForServer } from '../server/support/index.mjs';
-import { loadEntitiesOtherSide, prepareEntityPrimaryKeyForTemplates, prepareRelationship, prepareField, prepareEntity, loadRequiredConfigIntoEntity, loadEntitiesAnnotations, } from '../base-application/support/index.mjs';
+import { prepareField as prepareFieldForLiquibase, postPrepareEntity, prepareRelationshipForLiquibase, liquibaseComment, } from './support/index.mjs';
+import { getFKConstraintName, getUXConstraintName, prepareEntity as prepareEntityForServer } from '../server/support/index.mjs';
+import { prepareEntityPrimaryKeyForTemplates, prepareRelationship, prepareField, prepareEntity, loadRequiredConfigIntoEntity, } from '../base-application/support/index.mjs';
 import mavenPlugin from './support/maven-plugin.mjs';
 import { addLiquibaseChangelogCallback, addLiquibaseConstraintsChangelogCallback, addLiquibaseIncrementalChangelogCallback, } from './internal/needles.mjs';
-const BASE_CHANGELOG = {
-    addedFields: [],
-    removedFields: [],
-    addedRelationships: [],
-    removedRelationships: [],
-    relationshipsToRecreateForeignKeysOnly: [],
-};
-export default class LiquibaseGenerator extends BaseApplicationGenerator {
+import { prepareSqlApplicationProperties } from '../spring-data-relational/support/index.mjs';
+import { addEntityFiles, updateEntityFiles, updateConstraintsFiles, updateMigrateFiles, fakeFiles } from './changelog-files.mjs';
+import { fieldTypes } from '../../jdl/jhipster/index.mjs';
+const { CommonDBTypes: { LONG: TYPE_LONG }, } = fieldTypes;
+export default class LiquibaseGenerator extends BaseEntityChangesGenerator {
     recreateInitialChangelog;
+    numberOfRows;
+    databaseChangelogs = [];
     constructor(args, options, features) {
         super(args, options, { skipParseOptions: false, ...features });
         this.argument('entities', {
@@ -42,6 +42,7 @@ export default class LiquibaseGenerator extends BaseApplicationGenerator {
             required: false,
         });
         this.recreateInitialChangelog = this.options.recreateInitialChangelog ?? false;
+        this.numberOfRows = 10;
     }
     async beforeQueue() {
         await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION_SERVER);
@@ -52,13 +53,16 @@ export default class LiquibaseGenerator extends BaseApplicationGenerator {
     get preparing() {
         return this.asPreparingTaskGroup({
             preparing({ application }) {
-                application.liquibaseDefaultSchemaName =
-                    application.databaseTypeSql && application.devDatabaseTypeMysql && application.baseName ? application.baseName : '';
+                application.liquibaseDefaultSchemaName = '';
             },
             checkDatabaseCompatibility({ application }) {
                 if (!application.databaseTypeSql && !application.databaseTypeNeo4j) {
                     throw new Error(`Database type ${application.databaseType} is not supported`);
                 }
+                if (!application.databaseTypeSql) {
+                    // Add sql related derived properties
+                    prepareSqlApplicationProperties({ application });
+                }
             },
             addNeedles({ source, application }) {
                 source.addLiquibaseChangelog = changelog => this.editFile(`${application.srcMainResources}config/liquibase/master.xml`, addLiquibaseChangelogCallback(changelog));
@@ -67,7 +71,7 @@ export default class LiquibaseGenerator extends BaseApplicationGenerator {
             },
         });
     }
-    get [BaseApplicationGenerator.PREPARING]() {
+    get [BaseEntityChangesGenerator.PREPARING]() {
         return this.delegateTasksToBlueprint(() => this.preparing);
     }
     get preparingEachEntityField() {
@@ -79,7 +83,7 @@ export default class LiquibaseGenerator extends BaseApplicationGenerator {
             },
         });
     }
-    get [BaseApplicationGenerator.PREPARING_EACH_ENTITY_FIELD]() {
+    get [BaseEntityChangesGenerator.PREPARING_EACH_ENTITY_FIELD]() {
         return this.delegateTasksToBlueprint(() => this.preparingEachEntityField);
     }
     get preparingEachEntityRelationship() {
@@ -89,7 +93,7 @@ export default class LiquibaseGenerator extends BaseApplicationGenerator {
             },
         });
     }
-    get [BaseApplicationGenerator.PREPARING_EACH_ENTITY_RELATIONSHIP]() {
+    get [BaseEntityChangesGenerator.PREPARING_EACH_ENTITY_RELATIONSHIP]() {
         return this.delegateTasksToBlueprint(() => this.preparingEachEntityRelationship);
     }
     get postPreparingEachEntity() {
@@ -99,37 +103,77 @@ export default class LiquibaseGenerator extends BaseApplicationGenerator {
             },
         });
     }
-    get [BaseApplicationGenerator.POST_PREPARING_EACH_ENTITY]() {
+    get [BaseEntityChangesGenerator.POST_PREPARING_EACH_ENTITY]() {
         return this.delegateTasksToBlueprint(() => this.postPreparingEachEntity);
     }
     get default() {
         return this.asDefaultTaskGroup({
-            async calculateChangelogs({ application, entities }) {
-                if (!application.databaseTypeSql || this.options.skipDbChangelog) {
+            async calculateChangelogs({ application, entities, entityChanges }) {
+                if (!application.databaseTypeSql || this.options.skipDbChangelog || !entityChanges) {
                     return;
                 }
+                for (const databaseChangelog of entityChanges) {
+                    if (!databaseChangelog.newEntity) {
+                        // Previous entities are not prepared using default jhipster priorities.
+                        // Prepare them.
+                        const { previousEntity: entity } = databaseChangelog;
+                        loadRequiredConfigIntoEntity(entity, this.jhipsterConfigWithDefaults);
+                        prepareEntity(entity, this, application);
+                        prepareEntityForServer(entity);
+                        if (!entity.embedded && !entity.primaryKey) {
+                            prepareEntityPrimaryKeyForTemplates(entity, this);
+                        }
+                        for (const field of entity.fields ?? []) {
+                            prepareField(entity, field, this);
+                            prepareFieldForLiquibase(entity, field);
+                        }
+                        for (const relationship of entity.relationships ?? []) {
+                            prepareRelationship(entity, relationship, this, true);
+                            prepareRelationshipForLiquibase(entity, relationship);
+                        }
+                        postPrepareEntity({ application, entity });
+                    }
+                }
                 const entitiesToWrite = this.options.entities ?? entities.filter(entity => !entity.builtIn && !entity.skipServer).map(entity => entity.name);
-                const diffs = this._generateChangelogFromFiles(application);
-                for (const [fieldChanges] of diffs) {
-                    if (fieldChanges.type === 'entity-new') {
-                        await this._composeWithIncrementalChangelogProvider(entitiesToWrite, fieldChanges);
+                // Write only specified entities changelogs.
+                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 }));
                     }
-                    if (fieldChanges.addedFields.length > 0 || fieldChanges.removedFields.length > 0) {
-                        await this._composeWithIncrementalChangelogProvider(entitiesToWrite, fieldChanges);
+                    else if (databaseChangelog.addedFields.length > 0 || databaseChangelog.removedFields.length > 0) {
+                        this.databaseChangelogs.push(this.prepareChangelog({
+                            databaseChangelog: {
+                                ...databaseChangelog,
+                                fieldChangelog: true,
+                                addedRelationships: [],
+                                removedRelationships: [],
+                                relationshipsToRecreateForeignKeysOnly: [],
+                            },
+                            application,
+                        }));
                     }
                 }
-                // eslint-disable-next-line no-unused-vars
-                for (const [_fieldChanges, relationshipChanges] of diffs) {
-                    if (relationshipChanges &&
-                        relationshipChanges.incremental &&
-                        (relationshipChanges.addedRelationships.length > 0 || relationshipChanges.removedRelationships.length > 0)) {
-                        await this._composeWithIncrementalChangelogProvider(entitiesToWrite, relationshipChanges);
+                // 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)) {
+                        this.databaseChangelogs.push(this.prepareChangelog({
+                            databaseChangelog: {
+                                ...databaseChangelog,
+                                relationshipChangelog: true,
+                                addedFields: [],
+                                removedFields: [],
+                            },
+                            application,
+                        }));
                     }
                 }
+                this.databaseChangelogs = this.databaseChangelogs.filter(Boolean);
             },
         });
     }
-    get [BaseApplicationGenerator.DEFAULT]() {
+    get [BaseEntityChangesGenerator.DEFAULT]() {
         return this.delegateTasksToBlueprint(() => this.default);
     }
     get writing() {
@@ -146,9 +190,19 @@ export default class LiquibaseGenerator extends BaseApplicationGenerator {
             },
         });
     }
-    get [BaseApplicationGenerator.WRITING]() {
+    get [BaseEntityChangesGenerator.WRITING]() {
         return this.delegateTasksToBlueprint(() => this.writing);
     }
+    get writingEntities() {
+        return this.asWritingEntitiesTaskGroup({
+            writeChangelogs() {
+                return Promise.all(this.databaseChangelogs.map(databaseChangelog => this.writeChangelog({ databaseChangelog })));
+            },
+        });
+    }
+    get [BaseEntityChangesGenerator.WRITING_ENTITIES]() {
+        return this.delegateTasksToBlueprint(() => this.writingEntities);
+    }
     get postWriting() {
         return this.asPostWritingTaskGroup({
             customizeSpring({ source }) {
@@ -276,116 +330,257 @@ export default class LiquibaseGenerator extends BaseApplicationGenerator {
             },
         });
     }
-    get [BaseApplicationGenerator.POST_WRITING]() {
+    get [BaseEntityChangesGenerator.POST_WRITING]() {
         return this.asPostWritingTaskGroup(this.delegateTasksToBlueprint(() => this.postWriting));
     }
+    get postWritingEntities() {
+        return this.asPostWritingEntitiesTaskGroup({
+            postWriteChangelogs({ source }) {
+                return Promise.all(this.databaseChangelogs.map(databaseChangelog => this.postWriteChangelog({ source, databaseChangelog })));
+            },
+        });
+    }
+    get [BaseEntityChangesGenerator.POST_WRITING_ENTITIES]() {
+        return this.delegateTasksToBlueprint(() => this.postWritingEntities);
+    }
     /* ======================================================================== */
     /* private methods use within generator                                     */
     /* ======================================================================== */
-    _composeWithIncrementalChangelogProvider(entities, databaseChangelog) {
-        const skipWriting = entities.length !== 0 && !entities.includes(databaseChangelog.entityName);
-        return this.composeWithJHipster(GENERATOR_LIQUIBASE_CHANGELOGS, {
-            generatorOptions: {
-                databaseChangelog,
-                skipWriting,
-            },
-        });
+    isChangelogNew({ entityName, changelogDate }) {
+        return !fs.existsSync(this.destinationPath(`src/main/resources/config/liquibase/changelog/${changelogDate}_added_entity_${entityName}.xml`));
     }
     /**
-     * Generate changelog from differences between the liquibase entity and current entity.
+     * Write files for new entities.
      */
-    _generateChangelogFromFiles(application) {
-        const oldEntitiesConfig = Object.fromEntries(this.getExistingEntityNames()
-            .filter(entityName => fs.existsSync(this.getEntityConfigPath(entityName)))
-            .map(entityName => [
-            entityName,
-            { name: entityName, ...JSON.parse(fs.readFileSync(this.getEntityConfigPath(entityName)).toString()) },
-        ]));
-        if (application.generateBuiltInUserEntity) {
-            const user = this.sharedData.getEntity('User');
-            oldEntitiesConfig.User = user;
+    _writeLiquibaseFiles({ context: writeContext, changelogData }) {
+        const promises = [];
+        const context = {
+            ...writeContext,
+            skipFakeData: changelogData.skipFakeData,
+            fields: changelogData.allFields,
+            allFields: changelogData.allFields,
+            relationships: changelogData.relationships,
+        };
+        // Write initial liquibase files
+        promises.push(this.writeFiles({ sections: addEntityFiles, context }));
+        if (!changelogData.skipFakeData) {
+            promises.push(this.writeFiles({ sections: fakeFiles, context }));
         }
-        const entities = Object.values(oldEntitiesConfig);
-        loadEntitiesAnnotations(entities);
-        loadEntitiesOtherSide(entities);
-        addEntitiesOtherRelationships(entities);
-        for (const entity of entities.filter(entity => !entity.skipServer && !entity.builtIn)) {
-            loadRequiredConfigIntoEntity(entity, this.jhipsterConfigWithDefaults);
-            prepareEntity(entity, this, application);
-            prepareEntityForServer(entity);
-            if (!entity.embedded && !entity.primaryKey) {
-                prepareEntityPrimaryKeyForTemplates(entity, this);
-            }
-            for (const field of entity.fields ?? []) {
-                prepareField(entity, field, this);
-                prepareFieldForLiquibase(entity, field);
-            }
-            for (const relationship of entity.relationships ?? []) {
-                prepareRelationship(entity, relationship, this, true);
-                prepareRelationshipForLiquibase(entity, relationship);
-            }
-            postPrepareEntity({ application, entity });
+        return Promise.all(promises);
+    }
+    /**
+     * Write files for new entities.
+     */
+    _addLiquibaseFilesReferences({ entity, databaseChangelog, source }) {
+        const fileName = `${databaseChangelog.changelogDate}_added_entity_${entity.entityClass}`;
+        source.addLiquibaseChangelog({ changelogName: fileName, section: entity.incremental ? 'incremental' : 'base' });
+        if (entity.anyRelationshipIsOwnerSide) {
+            const constFileName = `${databaseChangelog.changelogDate}_added_entity_constraints_${entity.entityClass}`;
+            source.addLiquibaseChangelog({ changelogName: constFileName, section: entity.incremental ? 'incremental' : 'constraints' });
+        }
+    }
+    /**
+     * Write files for updated entities.
+     */
+    _writeUpdateFiles({ context: writeContext, changelogData }) {
+        const { addedFields, allFields, removedFields, addedRelationships, removedRelationships, hasFieldConstraint, hasRelationshipConstraint, shouldWriteAnyRelationship, relationshipsToRecreateForeignKeysOnly, } = changelogData;
+        const context = {
+            ...writeContext,
+            skipFakeData: changelogData.skipFakeData,
+            addedFields,
+            removedFields,
+            fields: addedFields,
+            allFields,
+            hasFieldConstraint,
+            addedRelationships,
+            removedRelationships,
+            relationships: addedRelationships,
+            hasRelationshipConstraint,
+            shouldWriteAnyRelationship,
+            relationshipsToRecreateForeignKeysOnly,
+        };
+        const promises = [];
+        promises.push(this.writeFiles({ sections: updateEntityFiles, context }));
+        if (!changelogData.skipFakeData && (changelogData.addedFields.length > 0 || shouldWriteAnyRelationship)) {
+            promises.push(this.writeFiles({ sections: fakeFiles, context }));
+            promises.push(this.writeFiles({ sections: updateMigrateFiles, context }));
+        }
+        if (hasFieldConstraint || shouldWriteAnyRelationship) {
+            promises.push(this.writeFiles({ sections: updateConstraintsFiles, context }));
         }
-        // Compare entity changes and create changelogs
-        return this.getExistingEntityNames().map(entityName => {
-            const newConfig = this.sharedData.getEntity(entityName);
-            const newFields = (newConfig.fields || []).filter((field) => !field.transient);
-            const newRelationships = newConfig.relationships || [];
-            if (this.recreateInitialChangelog ||
-                !application.incrementalChangelog ||
-                !oldEntitiesConfig[entityName] ||
-                !fs.existsSync(this.destinationPath(`src/main/resources/config/liquibase/changelog/${newConfig.changelogDate}_added_entity_${entityName}.xml`))) {
-                return [
-                    {
-                        ...BASE_CHANGELOG,
-                        incremental: newConfig.incrementalChangelog,
-                        changelogDate: newConfig.changelogDate,
-                        type: 'entity-new',
-                        entityName,
-                    },
-                ];
-            }
-            this._debug(`Calculating diffs for ${entityName}`);
-            const oldConfig = oldEntitiesConfig[entityName];
-            const oldFields = (oldConfig.fields || []).filter((field) => !field.transient);
-            const oldFieldNames = oldFields.filter(field => !field.id).map(field => field.fieldName);
-            const newFieldNames = newFields.filter(field => !field.id).map(field => field.fieldName);
-            // Calculate new fields
-            const addedFieldNames = newFieldNames.filter(fieldName => !oldFieldNames.includes(fieldName));
-            const addedFields = addedFieldNames.map(fieldName => newFields.find(field => fieldName === field.fieldName));
-            // Calculate removed fields
-            const removedFieldNames = oldFieldNames.filter(fieldName => !newFieldNames.includes(fieldName));
-            const removedFields = removedFieldNames.map(fieldName => oldFields.find(field => fieldName === field.fieldName));
-            const oldRelationships = oldConfig.relationships || [];
-            // Calculate changed/newly added relationships
-            const addedRelationships = newRelationships.filter(newRelationship => 
-            // id changes are not supported
-            !newRelationship.id &&
-                // check if the same relationship wasn't already part of the old config
-                !oldRelationships.some(oldRelationship => relationshipEquals(oldRelationship, newRelationship)));
-            // Calculate to be removed relationships
-            const removedRelationships = oldRelationships.filter(oldRelationship => 
-            // id changes are not supported
-            !oldRelationship.id &&
-                // check if there are relationships not anymore in the new config
-                !newRelationships.some(newRelationship => relationshipEquals(newRelationship, oldRelationship)));
-            // calcualte relationships that only need a foreign key recreation from the ones that are added
-            // we need both the added and the removed ones here
-            const relationshipsToRecreateForeignKeysOnly = addedRelationships
-                .filter(addedRelationship => removedRelationships.some(removedRelationship => relationshipNeedsForeignKeyRecreationOnly(removedRelationship, addedRelationship)))
-                .concat(removedRelationships.filter(removedRelationship => addedRelationships.some(addedRelationship => relationshipNeedsForeignKeyRecreationOnly(addedRelationship, removedRelationship))));
-            return [
-                { ...BASE_CHANGELOG, incremental: true, type: 'entity-update', entityName, addedFields, removedFields },
-                {
-                    ...BASE_CHANGELOG,
-                    incremental: true,
-                    type: 'entity-update',
-                    entityName,
-                    addedRelationships,
-                    removedRelationships,
-                    relationshipsToRecreateForeignKeysOnly,
-                },
-            ];
+        return Promise.all(promises);
+    }
+    /**
+     * 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)) {
+            source.addLiquibaseIncrementalChangelog({
+                changelogName: `${databaseChangelog.changelogDate}_updated_entity_migrate_${entity.entityClass}`,
+            });
+        }
+        if (changelogData.hasFieldConstraint || changelogData.shouldWriteAnyRelationship) {
+            source.addLiquibaseIncrementalChangelog({
+                changelogName: `${databaseChangelog.changelogDate}_updated_entity_constraints_${entity.entityClass}`,
+            });
+        }
+    }
+    /**
+     * @private
+     * Format As Liquibase Remarks
+     *
+     * @param {string} text - text to format
+     * @param {boolean} addRemarksTag - add remarks tag
+     * @returns formatted liquibase remarks
+     */
+    formatAsLiquibaseRemarks(text, addRemarksTag = false) {
+        return liquibaseComment(text, addRemarksTag);
+    }
+    prepareChangelog({ databaseChangelog, application }) {
+        if (!databaseChangelog.changelogDate) {
+            databaseChangelog.changelogDate = this.dateFormatForLiquibase();
+        }
+        const entity = databaseChangelog.entity;
+        if (entity.skipServer) {
+            return undefined;
+        }
+        // eslint-disable-next-line no-nested-ternary
+        const entityChanges = databaseChangelog.changelogData;
+        entityChanges.skipFakeData = application.skipFakeData || entity.skipFakeData;
+        entityChanges.allFields = entity.fields.filter(field => !field.transient);
+        if (databaseChangelog.newEntity) {
+            entityChanges.fields = entityChanges.allFields;
+        }
+        else {
+            entityChanges.addedFields = databaseChangelog.addedFields.filter(field => !field.transient);
+            entityChanges.removedFields = databaseChangelog.removedFields.filter(field => !field.transient);
+        }
+        const seed = `${entity.entityClass}-liquibase`;
+        this.resetEntitiesFakeData(seed);
+        entity.liquibaseFakeData = [];
+        // fakeDataCount must be limited to the size of required unique relationships.
+        Object.defineProperty(entity, 'fakeDataCount', {
+            get: () => {
+                const uniqueRelationships = entity.relationships.filter(rel => rel.unique && (rel.relationshipRequired || rel.id));
+                return _.min([entity.liquibaseFakeData.length, ...uniqueRelationships.map(rel => rel.otherEntity.fakeDataCount)]);
+            },
+            configurable: true,
         });
+        for (let rowNumber = 0; rowNumber < this.numberOfRows; rowNumber++) {
+            const rowData = {};
+            const fields = databaseChangelog.newEntity
+                ? // generate id fields first to improve reproducibility
+                    [...entityChanges.fields.filter(f => f.id), ...entityChanges.fields.filter(f => !f.id)]
+                : [...entityChanges.allFields.filter(f => f.id), ...entityChanges.addedFields.filter(f => !f.id)];
+            fields.forEach(field => {
+                if (field.derived) {
+                    Object.defineProperty(rowData, field.fieldName, {
+                        get: () => {
+                            if (!field.derivedEntity.liquibaseFakeData || rowNumber >= field.derivedEntity.liquibaseFakeData.length) {
+                                return undefined;
+                            }
+                            return field.derivedEntity.liquibaseFakeData[rowNumber][field.fieldName];
+                        },
+                    });
+                    return;
+                }
+                let data;
+                if (field.id && field.fieldType === TYPE_LONG) {
+                    data = rowNumber + 1;
+                }
+                else {
+                    data = field.generateFakeData();
+                }
+                rowData[field.fieldName] = data;
+            });
+            entity.liquibaseFakeData.push(rowData);
+        }
+        if (databaseChangelog.newEntity) {
+            entityChanges.relationships = entity.relationships;
+        }
+        else {
+            entityChanges.addedRelationships = databaseChangelog.addedRelationships;
+            entityChanges.removedRelationships = databaseChangelog.removedRelationships;
+            entityChanges.relationshipsToRecreateForeignKeysOnly = databaseChangelog.relationshipsToRecreateForeignKeysOnly;
+        }
+        /* Required by the templates */
+        databaseChangelog.writeContext = {
+            entity,
+            databaseChangelog,
+            changelogDate: databaseChangelog.changelogDate,
+            databaseType: entity.databaseType,
+            prodDatabaseType: entity.prodDatabaseType,
+            authenticationType: entity.authenticationType,
+            jhiPrefix: entity.jhiPrefix,
+            reactive: application.reactive,
+            incrementalChangelog: application.incrementalChangelog,
+            recreateInitialChangelog: this.recreateInitialChangelog,
+        };
+        if (databaseChangelog.newEntity) {
+            return databaseChangelog;
+        }
+        entityChanges.requiresUpdateChangelogs =
+            entityChanges.addedFields.length > 0 ||
+                entityChanges.removedFields.length > 0 ||
+                entityChanges.addedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable) ||
+                entityChanges.removedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable);
+        if (entityChanges.requiresUpdateChangelogs) {
+            entityChanges.hasFieldConstraint = entityChanges.addedFields.some(field => field.unique || !field.nullable);
+            entityChanges.hasRelationshipConstraint = entityChanges.addedRelationships.some(relationship => (relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable) && (relationship.unique || !relationship.nullable));
+            entityChanges.shouldWriteAnyRelationship = entityChanges.addedRelationships.some(relationship => relationship.shouldWriteRelationship || relationship.shouldWriteJoinTable);
+        }
+        return databaseChangelog;
+    }
+    writeChangelog({ databaseChangelog }) {
+        const { writeContext: context, changelogData } = databaseChangelog;
+        if (databaseChangelog.newEntity) {
+            return this._writeLiquibaseFiles({ context, changelogData });
+        }
+        if (changelogData.requiresUpdateChangelogs) {
+            return this._writeUpdateFiles({ context, changelogData });
+        }
+        return undefined;
+    }
+    postWriteChangelog({ databaseChangelog, source }) {
+        const { entity, changelogData } = databaseChangelog;
+        if (entity.skipServer) {
+            return undefined;
+        }
+        if (databaseChangelog.newEntity) {
+            return this._addLiquibaseFilesReferences({ entity, databaseChangelog, source });
+        }
+        if (changelogData.requiresUpdateChangelogs) {
+            return this._addUpdateFilesReferences({ entity, databaseChangelog, changelogData, source });
+        }
+        return undefined;
+    }
+    /**
+     * @private
+     * get a foreign key constraint name for tables in JHipster preferred style.
+     *
+     * @param {string} entityName - name of the entity
+     * @param {string} relationshipName - name of the related entity
+     * @param {string} prodDatabaseType - database type
+     * @param {boolean} noSnakeCase - do not convert names to snakecase
+     */
+    getFKConstraintName(entityName, relationshipName, prodDatabaseType, noSnakeCase) {
+        const result = getFKConstraintName(entityName, relationshipName, { prodDatabaseType, noSnakeCase });
+        this.validateResult(result);
+        return result.value;
+    }
+    /**
+     * @private
+     * get a unique constraint name for tables in JHipster preferred style.
+     *
+     * @param {string} entityName - name of the entity
+     * @param {string} columnName - name of the column
+     * @param {string} prodDatabaseType - database type
+     * @param {boolean} noSnakeCase - do not convert names to snakecase
+     */
+    getUXConstraintName(entityName, columnName, prodDatabaseType, noSnakeCase) {
+        const result = getUXConstraintName(entityName, columnName, { prodDatabaseType, noSnakeCase });
+        this.validateResult(result);
+        return result.value;
     }
 }

package/dist/generators/liquibase/internal/needles.mjs

@@ -17,10 +17,15 @@
  * limitations under the License.
  */
 import { createNeedleCallback } from '../../base/support/needles.mjs';
+const changelogType = {
+    base: 'liquibase-add-changelog',
+    incremental: 'liquibase-add-incremental-changelog',
+    constraints: 'liquibase-add-constraints-changelog',
+};
 const addLiquibaseChangelogToMasterCallback = ({ changelogName, needle }) => createNeedleCallback({
     needle,
     contentToAdd: `<include file="config/liquibase/changelog/${changelogName}.xml" relativeToChangelogFile="false"/>`,
 });
-export const addLiquibaseChangelogCallback = ({ changelogName }) => addLiquibaseChangelogToMasterCallback({ needle: 'liquibase-add-changelog', changelogName });
-export const addLiquibaseIncrementalChangelogCallback = ({ changelogName }) => addLiquibaseChangelogToMasterCallback({ needle: 'liquibase-add-incremental-changelog', changelogName });
-export const addLiquibaseConstraintsChangelogCallback = ({ changelogName }) => addLiquibaseChangelogToMasterCallback({ needle: 'liquibase-add-constraints-changelog', changelogName });
+export const addLiquibaseChangelogCallback = ({ changelogName, section = 'base' }) => addLiquibaseChangelogToMasterCallback({ needle: changelogType[section], changelogName });
+export const addLiquibaseIncrementalChangelogCallback = ({ changelogName }) => addLiquibaseChangelogCallback({ changelogName, section: 'incremental' });
+export const addLiquibaseConstraintsChangelogCallback = ({ changelogName }) => addLiquibaseChangelogCallback({ changelogName, section: 'constraints' });

package/dist/generators/liquibase/support/index.mjs

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// eslint-disable-next-line import/prefer-default-export
+export { default as liquibaseComment } from './formatting.mjs';
 export { default as postPrepareEntity } from './post-prepare-entity.mjs';
 export { default as prepareField } from './prepare-field.mjs';
 export * from './relationship.mjs';

package/dist/generators/{liquibase-changelogs → 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.javadoc, true) %>>
 <%_ for (field of fields) { _%>
-            <column name="<%= field.columnName %>" type="<%= field.columnType %>"<%- this.formatAsLiquibaseRemarks(field.javadoc, true) %><% if (field.id && field.liquibaseAutoIncrement) { %> autoIncrement="true" <%_ } %>>
+            <column name="<%= field.columnName %>" type="<%= field.columnType %>"<%- this.formatAsLiquibaseRemarks(field.javadoc, 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/initial_schema_sql.xml.ejs

@@ -40,7 +40,7 @@
         const idField = user.primaryKey.fields[0];
 _%>
         <createTable tableName="<%= user.entityTableName %>">
-            <column name="id" type="<%= idField.columnType %>"<% if (idField.liquibaseAutoIncrement) { %> autoIncrement="true"<% } %><% if (reactive && idField.fieldType === 'Long') { %> startWith="1050"<% } %>>
+            <column name="id" type="<%= idField.columnType %>"<% if (idField.liquibaseAutoIncrement) { %> autoIncrement="true" startWith="1050"<% } %>>
                 <constraints primaryKey="true" nullable="false"/>
             </column>
             <column name="login" type="varchar(50)">