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

package/dist/generators/base/support/faker.mjs

@@ -17,7 +17,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Faker } from '@faker-js/faker';
+import { Faker, base, en } from '@faker-js/faker';
 import Randexp from 'randexp';
 import { languageToJavaLanguage } from '../../languages/support/index.mjs';
 class RandexpWithFaker extends Randexp {
@@ -62,7 +62,7 @@ export async function createFaker(nativeLanguage = 'en') {
         locale = (await import('@faker-js/faker')).en;
     }
     const faker = new FakerWithRandexp({
-        locale: [locale],
+        locale: [locale, base, en],
     });
     faker.createRandexp = (pattern, m) => new RandexpWithFaker(pattern, m, faker);
     return faker;

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

@@ -16,6 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export * from './basename.mjs';
 export * from './configuration-helpers/options.mjs';
 export * from './config.mjs';
 export * from './contents.mjs';

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

@@ -219,7 +219,7 @@ export default class BaseApplicationGenerator extends BaseGenerator {
         return [firstArg];
     }
     /**
-     * @private
+     * @protected
      */
     getTaskFirstArgForPriority(priorityName) {
         if (![

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

@@ -19,7 +19,7 @@
 import _ from 'lodash';
 import pluralize from 'pluralize';
 import { getDatabaseTypeData, hibernateSnakeCase } from '../../server/support/index.mjs';
-import { createFaker, parseChangelog, stringHashCode, upperFirstCamelCase } from '../../base/support/index.mjs';
+import { createFaker, parseChangelog, stringHashCode, upperFirstCamelCase, getMicroserviceAppName } from '../../base/support/index.mjs';
 import { fieldToReference } from './prepare-field.mjs';
 import { getTypescriptKeyType, getEntityParentPathAddition } from '../../client/support/index.mjs';
 import { applicationTypes, authenticationTypes, binaryOptions, databaseTypes, entityOptions, fieldTypes, searchEngineTypes, } from '../../../jdl/jhipster/index.mjs';
@@ -125,7 +125,7 @@ export default function prepareEntity(entityWithConfig, generator, application)
         if (!entityWithConfig.microserviceName) {
             throw new Error('Microservice name for the entity is not found. Entity cannot be generated!');
         }
-        entityWithConfig.microserviceAppName = generator.getMicroserviceAppName(entityWithConfig.microserviceName);
+        entityWithConfig.microserviceAppName = getMicroserviceAppName({ microserviceName: entityWithConfig.microserviceName });
         entityWithConfig.skipServer = true;
     }
     _.defaults(entityWithConfig, {
@@ -441,6 +441,17 @@ export function loadRequiredConfigIntoEntity(entity, config) {
         packageName: config.packageName,
         packageFolder: config.packageFolder,
     });
+    if (entity.searchEngine === true && (!entity.microserviceName || entity.microserviceName === config.baseName)) {
+        // If the entity belongs to this application and searchEngine is true.
+        if (config.searchEngine && config.searchEngine !== NO_SEARCH_ENGINE) {
+            // Replace with the searchEngine from the application.
+            entity.searchEngine = config.searchEngine;
+        }
+        else {
+            entity.searchEngine = NO_SEARCH_ENGINE;
+            this?.log.warn('Search engine is enabled at entity level, but disabled at application level. Search engine will be disabled');
+        }
+    }
     if (config.applicationType === MICROSERVICE) {
         _.defaults(entity, {
             microserviceName: config.baseName,

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

@@ -29,34 +29,34 @@ const { BYTES, BYTE_BUFFER } = RelationalOnlyDBTypes;
 const fakeStringTemplateForFieldName = columnName => {
     let fakeTemplate;
     if (columnName === 'first_name') {
-        fakeTemplate = 'name.firstName';
+        fakeTemplate = 'person.firstName';
     }
     else if (columnName === 'last_name') {
-        fakeTemplate = 'name.lastName';
+        fakeTemplate = 'person.lastName';
     }
     else if (columnName === 'job_title') {
-        fakeTemplate = 'name.jobTitle';
+        fakeTemplate = 'person.jobTitle';
     }
     else if (columnName === 'telephone' || columnName === 'phone') {
         fakeTemplate = 'phone.number';
     }
     else if (columnName === 'zip_code' || columnName === 'post_code') {
-        fakeTemplate = 'address.zipCode';
+        fakeTemplate = 'location.zipCode';
     }
     else if (columnName === 'city') {
-        fakeTemplate = 'address.city';
+        fakeTemplate = 'location.city';
     }
     else if (columnName === 'street_name' || columnName === 'street') {
-        fakeTemplate = 'address.streetName';
+        fakeTemplate = 'location.street';
     }
     else if (columnName === 'country') {
-        fakeTemplate = 'address.country';
+        fakeTemplate = 'location.country';
     }
     else if (columnName === 'country_code') {
-        fakeTemplate = 'address.countryCode';
+        fakeTemplate = 'location.countryCode';
     }
     else if (columnName === 'color') {
-        fakeTemplate = 'commerce.color';
+        fakeTemplate = 'color.human';
     }
     else if (columnName === 'account') {
         fakeTemplate = 'finance.account';
@@ -86,13 +86,13 @@ const fakeStringTemplateForFieldName = columnName => {
         fakeTemplate = 'internet.url';
     }
     else {
-        fakeTemplate = 'random.words';
+        fakeTemplate = 'word.words';
     }
     return `{{${fakeTemplate}}}`;
 };
 /**
  * @param {*} field
- * @param {*} faker
+ * @param {import('@faker-js/faker').Faker} faker
  * @param {*} changelogDate
  * @param {string} type csv, cypress, json-serializable, ts
  * @returns fake value
@@ -133,7 +133,14 @@ function generateFakeDataForField(field, faker, changelogDate, type = 'csv') {
         data = `PT${faker.number.int({ min: 1, max: 59 })}M`;
         // eslint-disable-next-line no-template-curly-in-string
     }
-    else if ([INTEGER, LONG, FLOAT, '${floatType}', DOUBLE, BIG_DECIMAL, DURATION].includes(field.fieldType)) {
+    else if ([FLOAT, '${floatType}', DOUBLE, BIG_DECIMAL].includes(field.fieldType)) {
+        data = faker.number.float({
+            max: field.fieldValidateRulesMax ? parseInt(field.fieldValidateRulesMax, 10) : 32767,
+            min: field.fieldValidateRulesMin ? parseInt(field.fieldValidateRulesMin, 10) : 0,
+            precision: 0.01,
+        });
+    }
+    else if ([INTEGER, LONG, DURATION].includes(field.fieldType)) {
         data = faker.number.int({
             max: field.fieldValidateRulesMax ? parseInt(field.fieldValidateRulesMax, 10) : 32767,
             min: field.fieldValidateRulesMin ? parseInt(field.fieldValidateRulesMin, 10) : 0,

package/dist/generators/base-core/{generator-base.mjs → generator.mjs}

@@ -16,28 +16,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { basename, join as joinPath, dirname, relative, isAbsolute, join } from 'path';
-import { requireNamespace } from '@yeoman/namespace';
+import { basename, join as joinPath, dirname, relative, isAbsolute, join, extname } from 'path';
 import { createHash } from 'crypto';
 import { fileURLToPath } from 'url';
+import { statSync, rmSync, existsSync, readFileSync } from 'fs';
+import assert from 'assert';
+import { requireNamespace } from '@yeoman/namespace';
 import chalk from 'chalk';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import _ from 'lodash';
 import { simpleGit } from 'simple-git';
-import { statSync, rmSync, existsSync } from 'fs';
-import { lt as semverLessThan } from 'semver';
+import semver, { lt as semverLessThan } from 'semver';
 import YeomanGenerator from 'yeoman-generator';
-import semver from 'semver';
 import latestVersion from 'latest-version';
-import assert from 'assert';
 import SharedData from '../base/shared-data.mjs';
 import { CUSTOM_PRIORITIES, PRIORITY_NAMES, PRIORITY_PREFIX } from '../base/priorities.mjs';
-import { joinCallbacks } from '../base/support/index.mjs';
+import { createJHipster7Context, formatDateForChangelog, joinCallbacks } from '../base/support/index.mjs';
 import { packageJson } from '../../lib/index.mjs';
 import { GENERATOR_BOOTSTRAP } from '../generator-list.mjs';
 import NeedleApi from '../needle-api.mjs';
 import command from '../base/command.mjs';
-import { GENERATOR_JHIPSTER } from '../generator-constants.mjs';
+import { GENERATOR_JHIPSTER, YO_RC_FILE } from '../generator-constants.mjs';
 const { merge } = _;
 const { INITIALIZING, PROMPTING, CONFIGURING, COMPOSING, LOADING, PREPARING, DEFAULT, WRITING, POST_WRITING, INSTALL, POST_INSTALL, END } = PRIORITY_NAMES;
 const __filename = fileURLToPath(import.meta.url);
@@ -71,7 +70,6 @@ export default class CoreGenerator extends YeomanGenerator {
     /**
      * @deprecated
      */
-    configOptions;
     jhipsterTemplatesFolders;
     blueprintStorage;
     _jhipsterGenerator;
@@ -98,29 +96,31 @@ export default class CoreGenerator extends YeomanGenerator {
             type: Boolean,
             hide: true,
         });
-        this.parseJHipsterOptions(command.options);
         let jhipsterOldVersion = null;
         if (!this.options.help) {
-            // JHipster runtime config that should not be stored to .yo-rc.json.
-            this.configOptions = this.options.configOptions || {};
             /* Force config to use 'generator-jhipster' namespace. */
             this._config = this._getStorage('generator-jhipster');
             /* JHipster config using proxy mode used as a plain object instead of using get/set. */
             this.jhipsterConfig = this.config.createProxy();
             jhipsterOldVersion = this.jhipsterConfig.jhipsterVersion ?? null;
+            this.sharedData = this.createSharedData({ jhipsterOldVersion, help: this.options.help });
+            /* Options parsing must be executed after forcing jhipster storage namespace and after sharedData have been populated */
+            this.parseJHipsterOptions(command.options);
             // Don't write jhipsterVersion to .yo-rc.json when reproducible
-            if (!this.options.reproducible && !this.jhipsterConfig.jhipsterVersion) {
+            if (this.options.namespace.startsWith('jhipster:') &&
+                !this.options.namespace.startsWith('jhipster:bootstrap') &&
+                this.getFeatures().storeJHipsterVersion !== false &&
+                !this.options.reproducible &&
+                !this.jhipsterConfig.jhipsterVersion) {
                 this.jhipsterConfig.jhipsterVersion = packageJson.version;
             }
         }
-        this.sharedData = this.createSharedData({ jhipsterOldVersion, help: this.options.help });
         this.logger = this.log;
         if (this.options.help) {
             return;
         }
-        this.parseJHipsterOptions(command.options);
         this.registerPriorities(CUSTOM_PRIORITIES);
-        if (this.options.namespace !== 'jhipster:bootstrap') {
+        if (this.getFeatures().jhipsterBootstrap ?? true) {
             // jhipster:bootstrap is always required. Run it once the enviroment starts.
             this.env.queueTask('environment:run', async () => this.composeWithJHipster(GENERATOR_BOOTSTRAP).then(), {
                 once: 'queueJhipsterBootstrap',
@@ -168,6 +168,25 @@ export default class CoreGenerator extends YeomanGenerator {
             const source = this.sharedData.getSource();
             return [{ control, source }];
         }
+        if (priorityName === WRITING) {
+            if (existsSync(this.destinationPath(YO_RC_FILE))) {
+                try {
+                    const oldConfig = JSON.parse(readFileSync(this.destinationPath(YO_RC_FILE)).toString())[GENERATOR_JHIPSTER];
+                    const newConfig = this.config.getAll();
+                    const keys = [...new Set([...Object.keys(oldConfig), ...Object.keys(newConfig)])];
+                    const configChanges = Object.fromEntries(keys
+                        .filter(key => Array.isArray(newConfig[key])
+                        ? newConfig[key].length === oldConfig[key].length &&
+                            newConfig[key].find((element, index) => element !== oldConfig[key][index])
+                        : newConfig[key] !== oldConfig[key])
+                        .map(key => [key, { newValue: newConfig[key], oldValue: oldConfig[key] }]));
+                    return [{ control, configChanges }];
+                }
+                catch {
+                    // Fail to parse
+                }
+            }
+        }
         return [{ control }];
     }
     /**
@@ -176,6 +195,8 @@ export default class CoreGenerator extends YeomanGenerator {
     getTaskNames() {
         let priorities = super.getTaskNames();
         if (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));
         }
         return priorities;
@@ -220,21 +241,87 @@ export default class CoreGenerator extends YeomanGenerator {
         });
     }
     parseJHipsterArguments(jhipsterArguments = {}) {
-        const { positionalArguments = [] } = this.options;
+        const hasPositionalArguments = Boolean(this.options.positionalArguments);
+        let positionalArguments = hasPositionalArguments ? this.options.positionalArguments : this._args;
         const argumentEntries = Object.entries(jhipsterArguments);
-        if (positionalArguments.length > argumentEntries.length) {
+        if (hasPositionalArguments && positionalArguments.length > argumentEntries.length) {
             throw new Error('More arguments than allowed');
         }
-        argumentEntries.forEach(([argumentName, argumentDef], index) => {
-            if (positionalArguments.length > index) {
-                const argument = positionalArguments[index];
+        argumentEntries.find(([argumentName, argumentDef]) => {
+            if (positionalArguments.length > 0) {
+                let argument;
+                if (hasPositionalArguments || argumentDef.type !== Array) {
+                    // Positional arguments already parsed or a single argument.
+                    argument = positionalArguments.shift();
+                }
+                else {
+                    // Varags argument.
+                    argument = positionalArguments;
+                    positionalArguments = [];
+                }
                 const convertedValue = !argumentDef.type || argumentDef.type === Array ? argument : argumentDef.type(argument);
                 this[argumentName] = convertedValue;
             }
-            else if (argumentDef.required) {
-                throw new Error(`Missing required argument ${argumentName}`);
+            else {
+                if (argumentDef.required) {
+                    throw new Error(`Missing required argument ${argumentName}`);
+                }
+                return true;
             }
+            return false;
         });
+        // Arguments should only be parsed by the root generator, cleanup to don't be forwarded.
+        this.options.positionalArguments = [];
+    }
+    /**
+     * Generate a date to be used by Liquibase changelogs.
+     *
+     * @param {Boolean} [reproducible=true] - Set true if the changelog date can be reproducible.
+     *                                 Set false to create a changelog date incrementing the last one.
+     * @return {String} Changelog date.
+     */
+    dateFormatForLiquibase(reproducible) {
+        const control = this.sharedData.getControl();
+        reproducible = reproducible ?? control.reproducible;
+        // Use started counter or use stored creationTimestamp if creationTimestamp option is passed
+        const creationTimestamp = this.options.creationTimestamp ? this.config.get('creationTimestamp') : undefined;
+        let now = new Date();
+        // Miliseconds is ignored for changelogDate.
+        now.setMilliseconds(0);
+        // Run reproducible timestamp when regenerating the project with reproducible option or an specific timestamp.
+        if (reproducible || creationTimestamp) {
+            if (control.reproducibleLiquibaseTimestamp) {
+                // Counter already started.
+                now = control.reproducibleLiquibaseTimestamp;
+            }
+            else {
+                // Create a new counter
+                const newCreationTimestamp = creationTimestamp ?? this.config.get('creationTimestamp');
+                now = newCreationTimestamp ? new Date(newCreationTimestamp) : now;
+                now.setMilliseconds(0);
+            }
+            now.setMinutes(now.getMinutes() + 1);
+            control.reproducibleLiquibaseTimestamp = now;
+            // Reproducible build can create future timestamp, save it.
+            const lastLiquibaseTimestamp = this.jhipsterConfig.lastLiquibaseTimestamp;
+            if (!lastLiquibaseTimestamp || now.getTime() > lastLiquibaseTimestamp) {
+                this.config.set('lastLiquibaseTimestamp', now.getTime());
+            }
+        }
+        else {
+            // Get and store lastLiquibaseTimestamp, a future timestamp can be used
+            let lastLiquibaseTimestamp = this.jhipsterConfig.lastLiquibaseTimestamp;
+            if (lastLiquibaseTimestamp) {
+                lastLiquibaseTimestamp = new Date(lastLiquibaseTimestamp);
+                if (lastLiquibaseTimestamp >= now) {
+                    now = lastLiquibaseTimestamp;
+                    now.setSeconds(now.getSeconds() + 1);
+                    now.setMilliseconds(0);
+                }
+            }
+            this.jhipsterConfig.lastLiquibaseTimestamp = now.getTime();
+        }
+        return formatDateForChangelog(now);
     }
     /**
      * Alternative templatePath that fetches from the blueprinted generator, instead of the blueprint.
@@ -282,10 +369,11 @@ export default class CoreGenerator extends YeomanGenerator {
             }
         }
         return this.composeWith(generator, {
-            forwardOptions: true,
+            forwardOptions: false,
             ...options,
             generatorOptions: {
-                configOptions: this.configOptions,
+                ...this.options,
+                positionalArguments: undefined,
                 ...options?.generatorOptions,
             },
         });
@@ -365,8 +453,246 @@ export default class CoreGenerator extends YeomanGenerator {
     /**
      * write the given files using provided options.
      */
-    writeFiles(options) {
-        return this.internalWriteFiles(options);
+    async writeFiles(options) {
+        const paramCount = Object.keys(options).filter(key => ['sections', 'blocks', 'templates'].includes(key)).length;
+        assert(paramCount > 0, 'One of sections, blocks or templates is required');
+        assert(paramCount === 1, 'Only one of sections, blocks or templates must be provided');
+        const { sections, blocks, templates, rootTemplatesPath, context = this, transform: methodTransform = [] } = options;
+        const { _: commonSpec = {} } = sections || {};
+        const { transform: sectionTransform = [] } = commonSpec;
+        const startTime = new Date().getMilliseconds();
+        /* Build lookup order first has preference.
+         * Example
+         * rootTemplatesPath = ['reactive', 'common']
+         * jhipsterTemplatesFolders = ['/.../generator-jhispter-blueprint/server/templates', '/.../generator-jhispter/server/templates']
+         *
+         * /.../generator-jhispter-blueprint/server/templates/reactive/templatePath
+         * /.../generator-jhispter-blueprint/server/templates/common/templatePath
+         * /.../generator-jhispter/server/templates/reactive/templatePath
+         * /.../generator-jhispter/server/templates/common/templatePath
+         */
+        let rootTemplatesAbsolutePath;
+        if (!rootTemplatesPath) {
+            rootTemplatesAbsolutePath = this.jhipsterTemplatesFolders;
+        }
+        else if (typeof rootTemplatesPath === 'string' && isAbsolute(rootTemplatesPath)) {
+            rootTemplatesAbsolutePath = rootTemplatesPath;
+        }
+        else {
+            rootTemplatesAbsolutePath = this.jhipsterTemplatesFolders
+                .map(templateFolder => [].concat(rootTemplatesPath).map(relativePath => join(templateFolder, relativePath)))
+                .flat();
+        }
+        const normalizeEjs = file => file.replace('.ejs', '');
+        const resolveCallback = (val, fallback) => {
+            if (val === undefined) {
+                if (typeof fallback === 'function') {
+                    return resolveCallback(fallback);
+                }
+                return fallback;
+            }
+            if (typeof val === 'boolean' || typeof val === 'string') {
+                return val;
+            }
+            if (typeof val === 'function') {
+                return val.call(this, context) || false;
+            }
+            throw new Error(`Type not supported ${val}`);
+        };
+        const renderTemplate = async ({ sourceFile, destinationFile, options, noEjs, transform, binary }) => {
+            const extension = extname(sourceFile);
+            const isBinary = binary || ['.png', '.jpg', '.gif', '.svg', '.ico'].includes(extension);
+            const appendEjs = noEjs === undefined ? !isBinary && extension !== '.ejs' : !noEjs;
+            const ejsFile = appendEjs || extension === '.ejs';
+            let targetFile;
+            if (typeof destinationFile === 'function') {
+                targetFile = resolveCallback(destinationFile);
+            }
+            else {
+                targetFile = appendEjs ? normalizeEjs(destinationFile) : destinationFile;
+            }
+            let sourceFileFrom;
+            if (Array.isArray(rootTemplatesAbsolutePath)) {
+                // Look for existing templates
+                const existingTemplates = rootTemplatesAbsolutePath
+                    .map(rootPath => this.templatePath(rootPath, sourceFile))
+                    .filter(templateFile => existsSync(appendEjs ? `${templateFile}.ejs` : templateFile));
+                if (existingTemplates.length > 1) {
+                    const moreThanOneMessage = `Multiples templates were found for file ${sourceFile}, using the first
+templates: ${JSON.stringify(existingTemplates, null, 2)}`;
+                    if (existingTemplates.length > 2) {
+                        this.log.warn(`Possible blueprint conflict detected: ${moreThanOneMessage}`);
+                    }
+                    else {
+                        this.log.debug(moreThanOneMessage);
+                    }
+                }
+                sourceFileFrom = existingTemplates.shift();
+                if (sourceFileFrom === undefined) {
+                    throw new Error(`Template file ${sourceFile} was not found at ${rootTemplatesAbsolutePath}`);
+                }
+            }
+            else if (typeof rootTemplatesAbsolutePath === 'string') {
+                sourceFileFrom = this.templatePath(rootTemplatesAbsolutePath, sourceFile);
+            }
+            else {
+                sourceFileFrom = this.templatePath(sourceFile);
+            }
+            if (appendEjs) {
+                sourceFileFrom = `${sourceFileFrom}.ejs`;
+            }
+            if (!ejsFile) {
+                await this.copyTemplateAsync(sourceFileFrom, targetFile);
+            }
+            else {
+                let useAsync = true;
+                if (context.entityClass) {
+                    if (!context.baseName) {
+                        throw new Error('baseName is require at templates context');
+                    }
+                    const sourceBasename = basename(sourceFileFrom);
+                    const seed = `${context.entityClass}-${sourceBasename}${context.fakerSeed ?? ''}`;
+                    Object.values(this.sharedData.getApplication()?.sharedEntities ?? {}).forEach((entity) => {
+                        entity.resetFakerSeed(seed);
+                    });
+                    // Async calls will make the render method to be scheduled, allowing the faker key to change in the meantime.
+                    useAsync = false;
+                }
+                const renderOptions = {
+                    ...(options?.renderOptions ?? {}),
+                    // Set root for ejs to lookup for partials.
+                    root: rootTemplatesAbsolutePath,
+                    // ejs caching cause problem https://github.com/jhipster/generator-jhipster/pull/20757
+                    cache: false,
+                };
+                const copyOptions = { noGlob: true };
+                // TODO drop for v8 final release
+                const data = this.jhipster7Migration ? createJHipster7Context(this, context, { ignoreWarnings: true }) : context;
+                if (useAsync) {
+                    await this.renderTemplateAsync(sourceFileFrom, targetFile, data, renderOptions, copyOptions);
+                }
+                else {
+                    this.renderTemplate(sourceFileFrom, targetFile, data, renderOptions, copyOptions);
+                }
+            }
+            if (!isBinary && transform && transform.length) {
+                this.editFile(targetFile, ...transform);
+            }
+            return targetFile;
+        };
+        let parsedBlocks = blocks;
+        if (sections) {
+            assert(typeof sections === 'object', 'sections must be an object');
+            const parsedSections = Object.entries(sections)
+                .map(([sectionName, sectionBlocks]) => {
+                if (sectionName.startsWith('_'))
+                    return undefined;
+                assert(Array.isArray(sectionBlocks), `Section must be an array for ${sectionName}`);
+                return { sectionName, sectionBlocks };
+            })
+                .filter(Boolean);
+            parsedBlocks = parsedSections
+                .map(({ sectionName, sectionBlocks }) => {
+                return sectionBlocks.map((block, blockIdx) => {
+                    const blockSpecPath = `${sectionName}[${blockIdx}]`;
+                    assert(typeof block === 'object', `Block must be an object for ${blockSpecPath}`);
+                    return { blockSpecPath, ...block };
+                });
+            })
+                .flat();
+        }
+        let parsedTemplates;
+        if (parsedBlocks) {
+            parsedTemplates = parsedBlocks
+                .map((block, blockIdx) => {
+                const { blockSpecPath = `${blockIdx}`, path: blockPathValue = './', from: blockFromCallback, to: blockToCallback, condition: blockConditionCallback, transform: blockTransform = [], renameTo: blockRenameTo, } = block;
+                assert(typeof block === 'object', `Block must be an object for ${blockSpecPath}`);
+                assert(Array.isArray(block.templates), `Block templates must be an array for ${blockSpecPath}`);
+                const condition = resolveCallback(blockConditionCallback);
+                if (condition !== undefined && !condition) {
+                    return undefined;
+                }
+                if (typeof blockPathValue === 'function') {
+                    throw new Error(`Block path should be static for ${blockSpecPath}`);
+                }
+                const blockPath = resolveCallback(blockFromCallback, blockPathValue);
+                const blockTo = resolveCallback(blockToCallback, blockPath) || blockPath;
+                return block.templates.map((fileSpec, fileIdx) => {
+                    const fileSpecPath = `${blockSpecPath}[${fileIdx}]`;
+                    assert(typeof fileSpec === 'object' || typeof fileSpec === 'string' || typeof fileSpec === 'function', `File must be an object, a string or a function for ${fileSpecPath}`);
+                    if (typeof fileSpec === 'function') {
+                        fileSpec = fileSpec.call(this, context);
+                    }
+                    let { noEjs } = fileSpec;
+                    let derivedTransform;
+                    if (typeof blockTransform === 'boolean') {
+                        noEjs = !blockTransform;
+                        derivedTransform = [...methodTransform, ...sectionTransform];
+                    }
+                    else {
+                        derivedTransform = [...methodTransform, ...sectionTransform, ...blockTransform];
+                    }
+                    if (typeof fileSpec === 'string') {
+                        const sourceFile = join(blockPath, fileSpec);
+                        let destinationFile;
+                        if (blockRenameTo) {
+                            destinationFile = this.destinationPath(blockRenameTo.call(this, context, fileSpec, this));
+                        }
+                        else {
+                            destinationFile = this.destinationPath(blockTo, fileSpec);
+                        }
+                        return { sourceFile, destinationFile, noEjs, transform: derivedTransform };
+                    }
+                    const { options, file, renameTo, transform: fileTransform = [], binary } = fileSpec;
+                    let { sourceFile, destinationFile } = fileSpec;
+                    if (typeof fileTransform === 'boolean') {
+                        noEjs = !fileTransform;
+                    }
+                    else if (Array.isArray(fileTransform)) {
+                        derivedTransform = [...derivedTransform, ...fileTransform];
+                    }
+                    else if (fileTransform !== undefined) {
+                        throw new Error(`Transform ${fileTransform} value is not supported`);
+                    }
+                    const normalizedFile = resolveCallback(sourceFile || file);
+                    sourceFile = join(blockPath, normalizedFile);
+                    destinationFile = this.destinationPath(blockTo, join(resolveCallback(destinationFile || renameTo, normalizedFile)));
+                    const override = resolveCallback(fileSpec.override);
+                    if (override !== undefined && !override && this.fs.exists(destinationFile)) {
+                        this.log.debug(`skipping file ${destinationFile}`);
+                        return undefined;
+                    }
+                    // TODO remove for jhipster 8
+                    if (noEjs === undefined) {
+                        const { method } = fileSpec;
+                        if (method === 'copy') {
+                            noEjs = true;
+                        }
+                    }
+                    return {
+                        sourceFile,
+                        destinationFile,
+                        options,
+                        transform: derivedTransform,
+                        noEjs,
+                        binary,
+                    };
+                });
+            })
+                .flat()
+                .filter(template => template);
+        }
+        else {
+            parsedTemplates = templates.map(template => {
+                if (typeof template === 'string') {
+                    return { sourceFile: template, destinationFile: template };
+                }
+                return template;
+            });
+        }
+        const files = await Promise.all(parsedTemplates.map(template => renderTemplate(template)));
+        this.log.debug(`Time taken to write files: ${new Date().getMilliseconds() - startTime}ms`);
+        return files.filter(file => file);
     }
     editFile(file, options, ...transformCallbacks) {
         let actualOptions;
@@ -449,6 +775,14 @@ export default class CoreGenerator extends YeomanGenerator {
             return headerComments.join('\n').concat('\n', stringifyYaml(merge(parseYaml(content), value)));
         });
     }
+    /**
+     * Merge value to an existing json and write to destination
+     */
+    mergeDestinationJson(filepath, value) {
+        this.editFile(filepath, { create: true }, content => {
+            return JSON.stringify(merge(content ? JSON.parse(content) : {}, value), null, 2);
+        });
+    }
     /**
      * Shallow clone or convert dependencies to placeholder if needed.
      */
@@ -463,7 +797,7 @@ export default class CoreGenerator extends YeomanGenerator {
     loadNodeDependencies(destination, source) {
         Object.assign(destination, this.prepareDependencies(source));
     }
-    loadNodeDependenciesFromPackageJson(destination, packageJsonFile) {
+    loadNodeDependenciesFromPackageJson(destination, packageJsonFile = this.templatePath('../resources/package.json')) {
         const { devDependencies, dependencies } = this.fs.readJSON(packageJsonFile, {});
         this.loadNodeDependencies(destination, { ...devDependencies, ...dependencies });
     }
@@ -547,11 +881,15 @@ export default class CoreGenerator extends YeomanGenerator {
             LANG: 'en',
         });
     }
+    calculateApplicationId(applicationPath) {
+        const dirname = basename(applicationPath);
+        return `${createHash('shake256', { outputLength: 1 }).update(applicationPath, 'utf8').digest('hex')}-${dirname}`;
+    }
+    getSharedApplication(applicationFolder = this.destinationPath()) {
+        return this.options.sharedData.applications?.[this.calculateApplicationId(applicationFolder)];
+    }
     createSharedData({ jhipsterOldVersion, help, }) {
-        const destinationPath = this.destinationPath();
-        const dirname = basename(destinationPath);
-        const applicationId = this.options.applicationId ??
-            `${createHash('shake256', { outputLength: 1 }).update(destinationPath, 'utf8').digest('hex')}-${dirname}`;
+        const applicationId = this.options.applicationId ?? this.calculateApplicationId(this.destinationPath());
         if (this.options.sharedData.applications === undefined) {
             this.options.sharedData.applications = {};
         }