generator-jhipster 8.0.0-rc.1 → 8.1.0

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

@@ -21,6 +21,7 @@ import { fieldTypes, validations } from '../../../jdl/jhipster/index.mjs';
 import { getTypescriptType, prepareField as prepareClientFieldForTemplates } from '../../client/support/index.mjs';
 import { prepareField as prepareServerFieldForTemplates } from '../../server/support/index.mjs';
 import { fieldIsEnum } from './field-utils.mjs';
+import { mutateData } from '../../base/support/config.mjs';
 const { BlobTypes, CommonDBTypes, RelationalOnlyDBTypes } = fieldTypes;
 const { Validations: { MIN, MINLENGTH, MINBYTES, MAX, MAXBYTES, MAXLENGTH, PATTERN, REQUIRED, UNIQUE }, } = validations;
 const { TEXT, IMAGE, ANY } = BlobTypes;
@@ -267,14 +268,17 @@ export default function prepareField(entityWithConfig, field, generator) {
     return field;
 }
 function prepareCommonFieldForTemplates(entityWithConfig, field, generator) {
-    _.defaults(field, {
-        propertyName: field.fieldName,
+    mutateData(field, {
         path: [field.fieldName],
-        fieldNameCapitalized: _.upperFirst(field.fieldName),
-        fieldNameUnderscored: _.snakeCase(field.fieldName),
-        fieldNameHumanized: _.startCase(field.fieldName),
-        fieldTranslationKey: `${entityWithConfig.i18nKeyPrefix}.${field.fieldName}`,
-        tsType: getTypescriptType(field.fieldType),
+        propertyName: field.fieldName,
+        propertyNameCapitalized: ({ propertyName, propertyNameCapitalized }) => propertyNameCapitalized ?? _.upperFirst(propertyName),
+        fieldNameCapitalized: ({ fieldName, fieldNameCapitalized }) => fieldNameCapitalized ?? _.upperFirst(fieldName),
+        fieldNameUnderscored: ({ fieldName, fieldNameUnderscored }) => fieldNameUnderscored ?? _.snakeCase(fieldName),
+        fieldNameHumanized: ({ fieldName, fieldNameHumanized }) => fieldNameHumanized ?? _.startCase(fieldName),
+        fieldTranslationKey: ({ fieldName, fieldTranslationKey }) => fieldTranslationKey ?? `${entityWithConfig.i18nKeyPrefix}.${fieldName}`,
+        tsType: ({ fieldType, tsType }) => tsType ?? getTypescriptType(fieldType),
+    });
+    _.defaults(field, {
         entity: entityWithConfig,
     });
     const fieldType = field.fieldType;

package/dist/generators/base-application/support/prepare-relationship.mjs

@@ -22,20 +22,12 @@ import { databaseTypes, entityOptions, reservedKeywords, validations, checkAndRe
 import { upperFirstCamelCase } from '../../base/support/string.mjs';
 import { getJoinTableName, hibernateSnakeCase } from '../../server/support/index.mjs';
 import { stringifyApplicationData } from './debug.mjs';
+import { mutateData } from '../../base/support/config.mjs';
 const { isReservedTableName } = reservedKeywords;
 const { NEO4J, NO: DATABASE_NO } = databaseTypes;
 const { MapperTypes } = entityOptions;
 const { Validations: { REQUIRED }, } = validations;
 const { MAPSTRUCT } = MapperTypes;
-function _derivedProperties(relationship) {
-    _.defaults(relationship, {
-        relationshipOneToOne: relationship.relationshipType === 'one-to-one',
-        relationshipOneToMany: relationship.relationshipType === 'one-to-many',
-        relationshipManyToOne: relationship.relationshipType === 'many-to-one',
-        relationshipManyToMany: relationship.relationshipType === 'many-to-many',
-        otherEntityUser: relationship.otherEntityName === 'user',
-    });
-}
 function _defineOnUpdateAndOnDelete(relationship, generator) {
     relationship.onDelete = checkAndReturnRelationshipOnValue(relationship.options?.onDelete, generator);
     relationship.onUpdate = checkAndReturnRelationshipOnValue(relationship.options?.onUpdate, generator);
@@ -54,12 +46,19 @@ export default function prepareRelationship(entityWithConfig, relationship, gene
     Object.assign(relationship, {
         relationshipLeftSide: relationship.relationshipSide === 'left',
         relationshipRightSide: relationship.relationshipSide === 'right',
+        collection: relationship.relationshipType === 'one-to-many' || relationship.relationshipType === 'many-to-many',
+        relationshipOneToOne: relationship.relationshipType === 'one-to-one',
+        relationshipOneToMany: relationship.relationshipType === 'one-to-many',
+        relationshipManyToOne: relationship.relationshipType === 'many-to-one',
+        relationshipManyToMany: relationship.relationshipType === 'many-to-many',
+        otherEntityUser: relationship.otherEntityName === 'user',
     });
-    _.defaults(relationship, {
+    mutateData(relationship, {
         // let ownerSide true when type is 'many-to-one' for convenience.
         // means that this side should control the reference.
-        ownerSide: relationship.ownerSide || relationship.relationshipType === 'many-to-one' || relationship.relationshipSide === 'left',
-        collection: relationship.relationshipType === 'one-to-many' || relationship.relationshipType === 'many-to-many',
+        ownerSide: ({ ownerSide, relationshipLeftSide, relationshipManyToOne, relationshipOneToMany }) => ownerSide ?? (relationshipManyToOne || (relationshipLeftSide && !relationshipOneToMany)),
+        persistableRelationship: ({ persistableRelationship, ownerSide }) => persistableRelationship ?? ownerSide,
+        relationshipUpdateBackReference: ({ relationshipUpdateBackReference, ownerSide, relationshipRightSide }) => relationshipUpdateBackReference ?? (entityWithConfig.databaseType === 'neo4j' ? relationshipRightSide : !ownerSide),
     });
     relationship.otherSideReferenceExists = false;
     relationship.otherEntityIsEmbedded = otherEntityData.embedded;
@@ -80,6 +79,9 @@ export default function prepareRelationship(entityWithConfig, relationship, gene
             entityWithConfig.databaseType !== NEO4J &&
             entityWithConfig.databaseType !== DATABASE_NO &&
             (relationship.relationshipType === 'one-to-many' || relationship.ownerSide === false)) {
+            if (otherEntityData.builtInUser) {
+                throw new Error(`Error at entity ${entityName}: relationships with built-in User cannot have back reference`);
+            }
             throw new Error(`Error at entity ${entityName}: could not find the other side of the relationship ${stringifyApplicationData(relationship)}`);
         }
         else {
@@ -130,8 +132,9 @@ export default function prepareRelationship(entityWithConfig, relationship, gene
             : _.upperFirst(pluralize(relationship.relationshipName)),
         otherEntityNameCapitalizedPlural: pluralize(relationship.otherEntityNameCapitalized),
     });
-    _.defaults(relationship, {
+    mutateData(relationship, {
         propertyName: relationship.collection ? relationship.relationshipFieldNamePlural : relationship.relationshipFieldName,
+        propertyNameCapitalized: ({ propertyName, propertyNameCapitalized }) => propertyNameCapitalized ?? _.upperFirst(propertyName),
     });
     if (entityWithConfig.dto === MAPSTRUCT) {
         if (otherEntityData.dto !== MAPSTRUCT && !otherEntityData.builtInUser) {
@@ -205,7 +208,6 @@ export default function prepareRelationship(entityWithConfig, relationship, gene
     }
     relationship.reference = relationshipToReference(entityWithConfig, relationship);
     _defineOnUpdateAndOnDelete(relationship, generator);
-    _derivedProperties(relationship);
     return relationship;
 }
 function relationshipToReference(entity, relationship, pathPrefix = []) {

package/dist/generators/base-application/support/update-application-entities-transform.mjs

@@ -0,0 +1,52 @@
+import { readdir } from 'fs/promises';
+import { loadFile } from 'mem-fs';
+import { Minimatch } from 'minimatch';
+import { transform } from 'p-transform';
+import { basename, join } from 'path';
+import { GENERATOR_JHIPSTER } from '../../generator-constants.mjs';
+export const updateApplicationEntitiesTransform = ({ destinationPath, throwOnMissingConfig = true, }) => {
+    let yoRcFileInMemory;
+    const entities = [];
+    const yoRcFilePath = join(destinationPath, '.yo-rc.json');
+    const entitiesMatcher = new Minimatch(`${destinationPath}/.jhipster/*.json`);
+    return transform(file => {
+        if (file.path === yoRcFilePath) {
+            yoRcFileInMemory = file;
+            return undefined;
+        }
+        if (entitiesMatcher.match(file.path)) {
+            entities.push(basename(file.path).replace('.json', ''));
+        }
+        return file;
+    }, async function () {
+        try {
+            entities.push(...(await readdir(join(destinationPath, '.jhipster'))).map(file => file.replace('.json', '')));
+        }
+        catch {
+            // Directory does not exist
+        }
+        if (entities.length > 0) {
+            // The mem-fs instance requires another file instance to emit a change event
+            const yoRcFile = loadFile(yoRcFilePath);
+            // Prefer in-memory file if it exists
+            const yoRcFileContents = yoRcFileInMemory?.contents ?? yoRcFile.contents;
+            if (yoRcFileContents) {
+                const contents = JSON.parse(yoRcFileContents.toString());
+                if (contents[GENERATOR_JHIPSTER]) {
+                    contents[GENERATOR_JHIPSTER].entities = [...new Set([...(contents[GENERATOR_JHIPSTER].entities ?? []), ...entities])];
+                    yoRcFile.contents = Buffer.from(JSON.stringify(contents, null, 2));
+                    yoRcFileInMemory = yoRcFile;
+                }
+                else if (throwOnMissingConfig) {
+                    throw new Error(`File ${yoRcFile.path} is not a valid JHipster configuration file`);
+                }
+            }
+            else if (throwOnMissingConfig) {
+                throw new Error(`File ${yoRcFile.path} has no contents`);
+            }
+        }
+        if (yoRcFileInMemory) {
+            this.push(yoRcFileInMemory);
+        }
+    });
+};

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

@@ -116,7 +116,7 @@ export default class CoreGenerator extends YeomanGenerator {
         }
         this.registerPriorities(CUSTOM_PRIORITIES);
         if (this.getFeatures().jhipsterBootstrap ?? true) {
-            // jhipster:bootstrap is always required. Run it once the enviroment starts.
+            // jhipster:bootstrap is always required. Run it once the environment starts.
             this.env.queueTask('environment:run', async () => this.composeWithJHipster(GENERATOR_BOOTSTRAP).then(), {
                 once: 'queueJhipsterBootstrap',
                 startQueue: false,
@@ -141,6 +141,19 @@ export default class CoreGenerator extends YeomanGenerator {
         }
         return this._needleApi;
     }
+    /**
+     * Warn or throws check failure based on current skipChecks option.
+     * @param message
+     */
+    handleCheckFailure(message) {
+        if (this.skipChecks) {
+            this.log.warn(message);
+        }
+        else {
+            throw new Error(`${message}
+You can ignore this error by passing '--skip-checks' to jhipster command.`);
+        }
+    }
     /**
      * Check if the JHipster version used to generate an existing project is less than the passed version argument
      *
@@ -189,7 +202,7 @@ export default class CoreGenerator extends YeomanGenerator {
      */
     getTaskNames() {
         let priorities = super.getTaskNames();
-        if (this.options.skipPriorities) {
+        if (!this.features.disableSkipPriorities && this.options.skipPriorities) {
             // Make sure yeoman-generator will not throw on empty tasks due to filtered priorities.
             this.customLifecycle = priorities.length > 0;
             priorities = priorities.filter(priorityName => !this.options.skipPriorities.includes(priorityName));
@@ -226,7 +239,7 @@ export default class CoreGenerator extends YeomanGenerator {
             if (!optionDesc?.type || !optionDesc.scope || (common && optionDesc.scope === 'generator'))
                 return;
             let optionValue;
-            // Hidden options are test options, which doesn't rely on commoander for options parsing.
+            // Hidden options are test options, which doesn't rely on commander for options parsing.
             // We must parse environment variables manually
             if (this.options[optionDesc.name ?? optionName] === undefined && optionDesc.env && process.env[optionDesc.env]) {
                 optionValue = process.env[optionDesc.env];
@@ -413,7 +426,7 @@ export default class CoreGenerator extends YeomanGenerator {
                 generator = namespace;
             }
             else {
-                // Keep test compatibily were jhipster lookup does not run.
+                // Keep test compatibility were jhipster lookup does not run.
                 const found = ['/index.js', '/index.cjs', '/index.mjs', '/index.ts', '/index.cts', '/index.mts'].find(extension => {
                     const pathToLook = join(__dirname, `../${generator}${extension}`);
                     return existsSync(pathToLook) ? pathToLook : undefined;

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

@@ -64,7 +64,7 @@ export default class GeneratorBaseEntityChanges extends GeneratorBaseApplication
         const { generateBuiltInUserEntity, incrementalChangelog } = this.sharedData.getApplication();
         const entityNames = this.getExistingEntityNames();
         const entitiesByName = Object.fromEntries(entityNames.map(entityName => [entityName, this.sharedData.getEntity(entityName)]));
-        const entitiesWithExistingChangelog = entityNames.filter(entityName => !this.isChangelogNew({ entityName, changelogDate: entitiesByName[entityName].changelogDate }));
+        const entitiesWithExistingChangelog = entityNames.filter(entityName => !this.isChangelogNew({ entityName, changelogDate: entitiesByName[entityName].annotations?.changelogDate }));
         const previousEntitiesByName = Object.fromEntries(entityNames
             .filter(entityName => existsSync(this.getEntityConfigPath(entityName)))
             .map(entityName => [

package/dist/generators/base-workspaces/internal/docker-prompts.mjs

@@ -17,7 +17,8 @@
  * limitations under the License.
  */
 import chalk from 'chalk';
-import { readdirSync, statSync } from 'node:fs';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 import { loadConfigs } from './docker-base.mjs';
 import { applicationTypes, monitoringTypes, serviceDiscoveryTypes } from '../../../jdl/jhipster/index.mjs';
 import { convertSecretToBase64 } from '../../base/support/index.mjs';
@@ -115,7 +116,7 @@ async function askForPath() {
                 const path = this.destinationPath(input);
                 try {
                     if (statSync(path).isDirectory) {
-                        const appsFolders = getAppFolders.call(this, input, deploymentApplicationType);
+                        const appsFolders = getAppFolders.call(this, path, deploymentApplicationType);
                         if (appsFolders.length === 0) {
                             return deploymentApplicationType === MONOLITH
                                 ? `No monolith found in ${path}`
@@ -138,7 +139,7 @@ async function askForPath() {
         this.log.log(chalk.yellow(`The path "${this.directoryPath}" does not end with a trailing "/", adding it anyway.`));
         this.directoryPath += '/';
     }
-    this.appsFolders = getAppFolders.call(this, this.directoryPath, deploymentApplicationType);
+    this.appsFolders = getAppFolders.call(this, this.destinationPath(this.directoryPath), deploymentApplicationType);
     // Removing registry from appsFolders, using reverse for loop
     for (let i = this.appsFolders.length - 1; i >= 0; i--) {
         if (this.appsFolders[i] === 'jhipster-registry' || this.appsFolders[i] === 'registry') {
@@ -341,25 +342,25 @@ async function askForDockerPushCommand() {
  * @param deploymentApplicationType type of application being composed
  * @returns {Array} array of string representing app folders
  */
-export function getAppFolders(input, deploymentApplicationType) {
-    const destinationPath = this.destinationPath(input);
-    const files = readdirSync(destinationPath);
+export function getAppFolders(directory, deploymentApplicationType) {
+    const files = readdirSync(directory);
     const appsFolders = [];
     files.forEach(file => {
         try {
-            if (statSync(this.destinationPath(file)).isDirectory()) {
-                if (statSync(this.destinationPath(file, '.yo-rc.json')).isFile()) {
+            if (statSync(join(directory, file)).isDirectory()) {
+                const yoRcFile = join(directory, file, '.yo-rc.json');
+                if (statSync(yoRcFile).isFile()) {
                     try {
-                        const fileData = this.readDestinationJSON(`${file.name}/.yo-rc.json`);
+                        const fileData = JSON.parse(readFileSync(yoRcFile).toString());
                         if (fileData['generator-jhipster'].baseName !== undefined &&
                             (deploymentApplicationType === undefined ||
-                                deploymentApplicationType === fileData['generator-jhipster'].applicationType ||
+                                deploymentApplicationType === (fileData['generator-jhipster'].applicationType ?? MONOLITH) ||
                                 (deploymentApplicationType === MICROSERVICE && fileData['generator-jhipster'].applicationType === GATEWAY))) {
-                            appsFolders.push(file.name.match(/([^/]*)\/*$/)[1]);
+                            appsFolders.push(file.match(/([^/]*)\/*$/)[1]);
                         }
                     }
                     catch (err) {
-                        this.log.error(chalk.red(`${file}: this .yo-rc.json can't be read`));
+                        this.log.error(chalk.red(`${yoRcFile}: this .yo-rc.json can't be read`));
                         this.log.debug('Error:', err);
                     }
                 }

package/dist/generators/bootstrap/command.mjs

@@ -11,6 +11,12 @@ const command = {
             hide: true,
             scope: 'generator',
         },
+        refreshOnCommit: {
+            description: 'Refresh files on commit',
+            type: Boolean,
+            hide: true,
+            scope: 'generator',
+        },
     },
 };
 export default command;

package/dist/generators/bootstrap/generator.mjs

@@ -16,8 +16,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Duplex } from 'stream';
 import { forceYoFiles, createConflicterTransform, createYoResolveTransform } from '@yeoman/conflicter';
-import { isFilePending } from 'mem-fs-editor/state';
+import { isFileStateModified, isFilePending } from 'mem-fs-editor/state';
+import { createCommitTransform } from 'mem-fs-editor/transform';
 import BaseGenerator from '../base/index.mjs';
 import { createMultiStepTransform, createPrettierTransform, createForceWriteConfigFilesTransform, autoCrlfTransform, isPrettierConfigFilePath, createSortConfigFilesTransform, createESLintTransform, createRemoveUnusedImportsTransform, } from './support/index.mjs';
 import { PRETTIER_EXTENSIONS } from '../generator-constants.mjs';
@@ -34,8 +36,11 @@ export default class BootstrapGenerator extends BaseGenerator {
     static PRE_CONFLICTS = PRE_CONFLICTS_PRIORITY;
     upgradeCommand;
     skipPrettier;
+    prettierExtensions = PRETTIER_EXTENSIONS.split(',');
+    prettierOptions = { plugins: [] };
+    refreshOnCommit = false;
     constructor(args, options, features) {
-        super(args, options, { jhipsterBootstrap: false, uniqueGlobally: true, customCommitTask: () => this.commitSharedFs(), ...features });
+        super(args, options, { jhipsterBootstrap: false, uniqueGlobally: true, customCommitTask: () => this.commitTask(), ...features });
     }
     async beforeQueue() {
         loadStoredAppOptions.call(this);
@@ -52,7 +57,7 @@ export default class BootstrapGenerator extends BaseGenerator {
     get initializing() {
         return this.asInitializingTaskGroup({
             loadOptions() {
-                this.parseJHipsterOptions(command.options);
+                this.parseJHipsterOptions(command.options, command.configs);
             },
             validateBlueprint() {
                 if (this.jhipsterConfig.blueprints && !this.skipChecks) {
@@ -69,13 +74,8 @@ export default class BootstrapGenerator extends BaseGenerator {
     }
     get multistepTransform() {
         return {
-            queueTransform() {
+            queueMultistepTransform() {
                 this.queueMultistepTransform();
-                this.env.sharedFs.on('change', filePath => {
-                    if (createMultiStepTransform().templateFileFs.isTemplate(filePath)) {
-                        this.queueMultistepTransform();
-                    }
-                });
             },
         };
     }
@@ -84,13 +84,8 @@ export default class BootstrapGenerator extends BaseGenerator {
     }
     get preConflicts() {
         return {
-            async queueCommitPrettierConfig() {
-                await this.queueCommitPrettierConfig();
-                this.env.sharedFs.on('change', filePath => {
-                    if (isPrettierConfigFilePath(filePath)) {
-                        this.queueCommitPrettierConfig();
-                    }
-                });
+            queueCommitPrettierConfig() {
+                this.queueCommitPrettierConfig();
             },
         };
     }
@@ -101,14 +96,22 @@ export default class BootstrapGenerator extends BaseGenerator {
      * Queue multi step templates transform
      */
     queueMultistepTransform() {
+        const multiStepTransform = createMultiStepTransform();
+        const listener = filePath => {
+            if (multiStepTransform.templateFileFs.isTemplate(filePath)) {
+                this.env.sharedFs.removeListener('change', listener);
+                this.queueMultistepTransform();
+            }
+        };
         this.queueTask({
-            method: () => {
-                const multiStepTransform = createMultiStepTransform();
-                const filter = file => isFilePending(file) && multiStepTransform.templateFileFs.isTemplate(file.path);
-                return this.env.applyTransforms([multiStepTransform], {
+            method: async () => {
+                await this.pipeline({
                     name: 'applying multi-step templates',
-                    streamOptions: { filter },
-                });
+                    filter: file => isFileStateModified(file) && multiStepTransform.templateFileFs.isTemplate(file.path),
+                    refresh: true,
+                    allowOverride: true,
+                }, multiStepTransform);
+                this.env.sharedFs.on('change', listener);
             },
             taskName: MULTISTEP_TRANSFORM_QUEUE,
             queueName: MULTISTEP_TRANSFORM_QUEUE,
@@ -116,9 +119,16 @@ export default class BootstrapGenerator extends BaseGenerator {
         });
     }
     queueCommitPrettierConfig() {
+        const listener = filePath => {
+            if (isPrettierConfigFilePath(filePath)) {
+                this.env.sharedFs.removeListener('change', listener);
+                this.queueCommitPrettierConfig();
+            }
+        };
         this.queueTask({
             method: async () => {
                 await this.commitPrettierConfig();
+                this.env.sharedFs.on('change', listener);
             },
             taskName: 'commitPrettierConfig',
             queueName: PRE_CONFLICTS_QUEUE,
@@ -126,37 +136,66 @@ export default class BootstrapGenerator extends BaseGenerator {
         });
     }
     async commitPrettierConfig() {
-        const filter = file => isFilePending(file) && isPrettierConfigFilePath(file.path);
-        await this.commitSharedFs(this.env.sharedFs.stream({ filter }));
-        this.log.ok('committed prettier configuration files');
+        await this.commitSharedFs({
+            log: 'prettier configuration files committed to disk',
+            filter: file => isPrettierConfigFilePath(file.path),
+        });
+    }
+    async commitTask() {
+        await this.commitSharedFs({ refresh: this.refreshOnCommit }, ...this.env
+            .findFeature('commitTransformFactory')
+            .map(({ feature }) => feature())
+            .flat());
     }
     /**
      * Commits the MemFs to the disc.
-     * @param stream - files stream, defaults to this.sharedFs.stream().
      */
-    async commitSharedFs(stream = this.env.sharedFs.stream({ filter: isFilePending })) {
-        const { skipYoResolve } = this.options;
-        const ignoreErrors = this.options.ignoreErrors || this.upgradeCommand;
+    async commitSharedFs({ log, ...options } = {}, ...transforms) {
+        const skipYoResolveTransforms = [];
+        if (!this.options.skipYoResolve) {
+            skipYoResolveTransforms.push(createYoResolveTransform());
+        }
+        const prettierTransforms = [];
+        if (!this.skipPrettier) {
+            const ignoreErrors = this.options.ignoreErrors || this.upgradeCommand;
+            prettierTransforms.push(createESLintTransform.call(this, { ignoreErrors, extensions: 'ts,js' }), createRemoveUnusedImportsTransform.call(this, { ignoreErrors }), await createPrettierTransform.call(this, {
+                ignoreErrors,
+                prettierPackageJson: true,
+                prettierJava: !this.jhipsterConfig.skipServer,
+                extensions: this.prettierExtensions.join(','),
+                prettierOptions: this.prettierOptions,
+            }));
+        }
+        const autoCrlfTransforms = [];
+        if (this.jhipsterConfig.autoCrlf) {
+            autoCrlfTransforms.push(await autoCrlfTransform({ baseDir: this.destinationPath() }));
+        }
         const transformStreams = [
-            ...(skipYoResolve ? [] : [createYoResolveTransform()]),
+            ...skipYoResolveTransforms,
             forceYoFiles(),
             createSortConfigFilesTransform(),
             createForceWriteConfigFilesTransform(),
-            ...(this.skipPrettier
-                ? []
-                : [
-                    createESLintTransform.call(this, { ignoreErrors, extensions: 'ts,js' }),
-                    createRemoveUnusedImportsTransform.call(this, { ignoreErrors }),
-                    await createPrettierTransform.call(this, {
-                        ignoreErrors,
-                        prettierPackageJson: true,
-                        prettierJava: !this.jhipsterConfig.skipServer,
-                        extensions: PRETTIER_EXTENSIONS,
-                    }),
-                ]),
-            ...(this.jhipsterConfig.autoCrlf ? [autoCrlfTransform(this.createGit())] : []),
-            createConflicterTransform(this.env.adapter, { ...this.env.conflicterOptions, memFs: this.env.sharedFs }),
+            ...prettierTransforms,
+            ...autoCrlfTransforms,
+            createConflicterTransform(this.env.adapter, { ...this.env.conflicterOptions }),
+            createCommitTransform(),
         ];
-        await this.fs.commit(transformStreams, stream);
+        await this.pipeline({
+            refresh: false,
+            // Let pending files pass through.
+            pendingFiles: false,
+            ...options,
+            // Disable progress since it blocks stdin.
+            disabled: true,
+        }, ...transforms, 
+        // Filter out pending files.
+        Duplex.from(async function* (files) {
+            for await (const file of files) {
+                if (isFilePending(file)) {
+                    yield file;
+                }
+            }
+        }), ...transformStreams);
+        this.log.ok(log ?? 'files committed to disk');
     }
 }

package/dist/generators/bootstrap/support/auto-crlf-transform.mjs

@@ -18,8 +18,11 @@
  */
 import { stat } from 'fs/promises';
 import { createReadStream } from 'fs';
+import { relative } from 'path';
 import { transform } from 'p-transform';
 import { isBinaryFile } from 'isbinaryfile';
+import { simpleGit } from 'simple-git';
+import { isFileStateModified } from 'mem-fs-editor/state';
 import { normalizeLineEndings } from '../../base/support/index.mjs';
 /**
  * Detect the file first line endings
@@ -44,27 +47,37 @@ export function detectCrLf(filePath) {
         });
     });
 }
-const autoCrlfTransform = (git) => transform(async (file) => {
-    if (!file.contents) {
-        return file;
-    }
-    if (await isBinaryFile(file.contents)) {
-        return file;
-    }
-    const fstat = await stat(file.path);
-    if (!fstat.isFile()) {
-        return file;
+const autoCrlfTransform = async ({ baseDir }) => {
+    const git = simpleGit({ baseDir }).env({
+        ...process.env,
+        LANG: 'en',
+    });
+    if (!(await git.checkIsRepo())) {
+        throw new Error(`${baseDir} is not inside a git repository`);
     }
-    const attributes = Object.fromEntries((await git.raw('check-attr', 'binary', 'eol', '--', file.path))
-        .split(/\r\n|\r|\n/)
-        .map(attr => attr.split(':'))
-        .map(([_file, attr, value]) => [attr, value]));
-    if (attributes.binary === 'set' || attributes.eol === 'lf') {
+    return transform(async (file) => {
+        if (!isFileStateModified(file) || !file.path.startsWith(baseDir)) {
+            return file;
+        }
+        try {
+            const fstat = await stat(file.path);
+            if (fstat.isFile()) {
+                if (await isBinaryFile(file.contents)) {
+                    return file;
+                }
+                const attrs = Object.fromEntries((await git.raw('check-attr', 'binary', 'eol', '--', relative(baseDir, file.path)))
+                    .split(/\r\n|\r|\n/)
+                    .map(attr => attr.split(':'))
+                    .map(([_file, attr, value]) => [attr, value]));
+                if (attrs.eol === 'crlf' || (attrs.binary !== 'set' && attrs.eol !== 'lf' && (await detectCrLf(file.path)))) {
+                    file.contents = Buffer.from(normalizeLineEndings(file.contents.toString(), '\r\n'));
+                }
+            }
+        }
+        catch {
+            // File doesn't exist.
+        }
         return file;
-    }
-    if (attributes.eol === 'crlf' || (await detectCrLf(file.path))) {
-        file.contents = Buffer.from(normalizeLineEndings(file.contents.toString(), '\r\n'));
-    }
-    return file;
-});
+    });
+};
 export default autoCrlfTransform;

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

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 import { passthrough } from 'p-transform';
-import { isFileStateDeleted } from 'mem-fs-editor/state';
+import { isFileStateModified } from 'mem-fs-editor/state';
 import ESLint from 'eslint';
 import { Minimatch } from 'minimatch';
 import { getPackageRoot } from '../../../lib/index.mjs';
@@ -46,12 +46,9 @@ export const createESLintTransform = function (transformOptions = {}) {
         },
     });
     return passthrough(async (file) => {
-        if (!minimatch.match(file.path) || isFileStateDeleted(file)) {
+        if (!minimatch.match(file.path) || !isFileStateModified(file)) {
             return;
         }
-        if (!file.contents) {
-            throw new Error(`File content doesn't exist for ${file.relative}`);
-        }
         try {
             if (await eslint.isPathIgnored(file.path)) {
                 return;

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

@@ -1,12 +1,12 @@
 import { extname } from 'path';
 import { passthrough } from '@yeoman/transform';
-import { isFileStateDeleted } from 'mem-fs-editor/state';
+import { isFileStateModified } from 'mem-fs-editor/state';
 import { removeUnusedImports } from 'java-lint';
 // eslint-disable-next-line import/prefer-default-export
 export const createRemoveUnusedImportsTransform = function (options = {}) {
     const { ignoreErrors } = options;
     return passthrough((file) => {
-        if (extname(file.path) === '.java' && !isFileStateDeleted(file)) {
+        if (extname(file.path) === '.java' && isFileStateModified(file)) {
             if (file.contents) {
                 try {
                     file.contents = Buffer.from(removeUnusedImports(file.contents.toString('utf8')));