generator-jhipster 8.0.0-rc.1 → 8.0.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,18 @@ 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)),
+        relationshipUpdateBackReference: ({ relationshipUpdateBackReference, ownerSide, relationshipRightSide }) => relationshipUpdateBackReference ?? (entityWithConfig.databaseType === 'neo4j' ? relationshipRightSide : !ownerSide),
     });
     relationship.otherSideReferenceExists = false;
     relationship.otherEntityIsEmbedded = otherEntityData.embedded;
@@ -130,8 +128,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 +204,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-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/generator.mjs

@@ -17,7 +17,8 @@
  * limitations under the License.
  */
 import { forceYoFiles, createConflicterTransform, createYoResolveTransform } from '@yeoman/conflicter';
-import { isFilePending } from 'mem-fs-editor/state';
+import { isFileStateModified } 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,6 +35,8 @@ export default class BootstrapGenerator extends BaseGenerator {
     static PRE_CONFLICTS = PRE_CONFLICTS_PRIORITY;
     upgradeCommand;
     skipPrettier;
+    prettierExtensions = PRETTIER_EXTENSIONS.split(',');
+    prettierOptions = { plugins: [] };
     constructor(args, options, features) {
         super(args, options, { jhipsterBootstrap: false, uniqueGlobally: true, customCommitTask: () => this.commitSharedFs(), ...features });
     }
@@ -69,13 +72,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 +82,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 +94,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 +117,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 +134,50 @@ 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 commited to disk',
+            filter: file => isPrettierConfigFilePath(file.path),
+        });
     }
     /**
      * 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 } = {}) {
+        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);
+        // Disable progress since it blocks stdin.
+        await this.pipeline({
+            refresh: false,
+            ...options,
+            disabled: true,
+        }, ...transformStreams);
+        this.log.ok(log ?? 'files commited 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')));

package/dist/generators/bootstrap/support/multi-step-transform/index.mjs

@@ -16,39 +16,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Duplex } from 'stream';
-import PQueue from 'p-queue';
-import { isFilePending } from 'mem-fs-editor/state';
+import { transform } from 'p-transform';
 import TemplateFileFs from './template-file-fs.mjs';
 // eslint-disable-next-line import/prefer-default-export
 export const createMultiStepTransform = () => {
-    const twoStepTemplateQueue = new PQueue({ concurrency: 1, autoStart: false });
     const templateFileFs = new TemplateFileFs({});
-    const pendingFiles = [];
-    const duplex = Duplex.from(async function* (source) {
-        for await (const file of source) {
-            if (file.contents && templateFileFs.isTemplate(file.path)) {
-                const templateFile = templateFileFs.add(file.path, file.contents.toString());
-                if (templateFile.rootTemplate) {
-                    // If multi-step root, postpone.
-                    twoStepTemplateQueue.add(() => {
-                        if (pendingFiles.includes(templateFile.basePath)) {
-                            return;
-                        }
-                        file.path = templateFile.basePath;
-                        file.contents = Buffer.from(templateFile.render().concat('\n'));
-                    });
-                }
-                else {
-                    delete file.state;
-                }
-            }
-            else if (isFilePending(file)) {
-                pendingFiles.push(file.path);
-            }
-            yield file;
+    const templateFiles = [];
+    const duplex = transform((file) => {
+        if (!templateFileFs.isTemplate(file.path)) {
+            throw new Error(`File ${file.path} is not supported`);
+        }
+        const templateFile = templateFileFs.add(file);
+        if (templateFile.rootTemplate) {
+            templateFiles.push(templateFile);
+        }
+        return undefined;
+    }, async function () {
+        for (const templateFile of templateFiles) {
+            const file = templateFile.file;
+            file.path = templateFile.basePath;
+            file.contents = Buffer.from(templateFile.render().concat('\n'));
+            this.push(templateFile.file);
         }
-        await twoStepTemplateQueue.start().onIdle();
     });
     duplex.templateFileFs = templateFileFs;
     return duplex;

package/dist/generators/bootstrap/support/multi-step-transform/template-file-fs.mjs

@@ -21,6 +21,10 @@ import path from 'path';
 import { minimatch } from 'minimatch';
 import TemplateFile from './template-file.mjs';
 export default class TemplateFileFs {
+    fragmentFiles;
+    rootFiles = [];
+    extension;
+    delimiter;
     constructor(options = {}) {
         this.extension = options.extension || 'jhi';
         this.delimiter = options.delimiter || '&';
@@ -35,12 +39,14 @@ export default class TemplateFileFs {
     isDerivedTemplate(filePath) {
         return minimatch(filePath, `**/*.${this.extension}.*`, { dot: true });
     }
-    add(filePath, contents) {
-        assert(filePath, 'filePath is required');
-        assert(contents, 'contents is required');
-        const templateFile = this.get(filePath);
-        templateFile.compile(filePath, contents, { delimiter: this.delimiter });
-        if (!templateFile.rootTemplate) {
+    add(file) {
+        assert(file.contents, 'contents is required');
+        const templateFile = this.get(file.path);
+        templateFile.compile(file.path, file.contents.toString(), { delimiter: this.delimiter });
+        if (templateFile.rootTemplate) {
+            templateFile.file = file;
+        }
+        else {
             this.get(templateFile.parentPath).addFragment(templateFile);
         }
         return templateFile;

package/dist/generators/bootstrap/support/multi-step-transform/template-file.mjs

@@ -4,6 +4,7 @@ import debugBuilder from 'debug';
 import ejs from 'ejs';
 import TemplateData from './template-data.mjs';
 export default class TemplateFile {
+    file;
     constructor(filename, extension) {
         this._filename = filename;
         this._extension = extension;

package/dist/generators/bootstrap/support/prettier-support.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 prettier from 'prettier';
 import prettierPluginJava from 'prettier-plugin-java';
 import prettierPluginProperties from 'prettier-plugin-properties';
@@ -34,7 +34,7 @@ export const createPrettierTransform = async function (options = {}) {
     const globExpression = extensions.includes(',') ? `**/*.{${extensions}}` : `**/*.${extensions}`;
     const minimatch = new Minimatch(globExpression, { dot: true });
     return passthrough(async (file) => {
-        if (!minimatch.match(file.path) || isFileStateDeleted(file)) {
+        if (!minimatch.match(file.path) || !isFileStateModified(file)) {
             return;
         }
         if (!file.contents) {

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

@@ -76,9 +76,6 @@ export default class BootstrapApplicationGenerator extends BaseApplicationGenera
                     if (application.clientFrameworkVue) {
                         prettierExtensions = `${prettierExtensions},vue`;
                     }
-                    if (application.clientFrameworkSvelte) {
-                        prettierExtensions = `${prettierExtensions},svelte`;
-                    }
                 }
                 if (!application.skipServer) {
                     prettierExtensions = `${prettierExtensions},java`;
@@ -149,6 +146,16 @@ export default class BootstrapApplicationGenerator extends BaseApplicationGenera
             postPreparingEntities({ entities }) {
                 preparePostEntitiesCommonDerivedProperties(entities);
             },
+            checkProperties({ entities }) {
+                for (const entity of entities) {
+                    const properties = [...entity.fields.map(entity => entity.propertyName), ...entity.relationships.map(rel => rel.propertyName)];
+                    if (new Set(properties).size !== properties.length) {
+                        // Has duplicated properties.
+                        const duplicated = [...new Set(properties.filter((v, i, a) => a.indexOf(v) !== i))];
+                        throw new Error(`You have duplicated properties ${duplicated.join(', ')}`);
+                    }
+                }
+            },
         });
     }
     get [BaseApplicationGenerator.DEFAULT]() {

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

@@ -21,6 +21,7 @@ import os from 'os';
 import * as _ from 'lodash-es';
 import chalk from 'chalk';
 import { passthrough } from '@yeoman/transform';
+import { isFileStateModified } from 'mem-fs-editor/state';
 import BaseApplicationGenerator from '../base-application/index.mjs';
 import { addFakerToEntity, loadEntitiesAnnotations, loadEntitiesOtherSide, stringifyApplicationData, prepareEntity as prepareEntityForTemplates, prepareField as prepareFieldForTemplates, prepareRelationship, } from '../base-application/support/index.mjs';
 import { createUserEntity } from './utils.mjs';
@@ -243,18 +244,20 @@ export default class BootstrapApplicationBase extends BaseApplicationGenerator {
                         }
                     }
                 };
-                this.queueTransformStream(passthrough(file => {
-                    if (file.contents && isPackageJson(file)) {
+                this.queueTransformStream({
+                    name: 'updating package.json dependencies versions',
+                    filter: file => isFileStateModified(file) && file.path.startsWith(this.destinationPath()) && isPackageJson(file),
+                    refresh: false,
+                }, passthrough(file => {
+                    const contents = file.contents.toString();
+                    if (contents.includes('null')) {
                         const content = JSON.parse(file.contents.toString());
                         populateNullValues(content.dependencies);
                         populateNullValues(content.devDependencies);
                         populateNullValues(content.peerDependencies);
                         file.contents = Buffer.from(`${JSON.stringify(content, null, 2)}\n`);
                     }
-                }), {
-                    name: 'updating package.json dependency versions',
-                    streamOptions: { filter: isPackageJson },
-                });
+                }));
             },
         });
     }

package/dist/generators/bootstrap-application-server/generator.mjs

@@ -122,10 +122,10 @@ export default class BoostrapApplicationServer extends BaseApplicationGenerator
             prepareEntity({ entity }) {
                 prepareEntityServerForTemplates(entity);
             },
-            preparePrimaryKey({ entity }) {
+            preparePrimaryKey({ entity, application }) {
                 // If primaryKey doesn't exist, create it.
                 if (!entity.embedded && !entity.primaryKey) {
-                    prepareEntityPrimaryKeyForTemplates(entity, this);
+                    prepareEntityPrimaryKeyForTemplates.call(this, { entity, application });
                 }
             },
         });