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

package/dist/generators/workspaces/generator.mjs

@@ -16,70 +16,67 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import fs from 'fs';
-import path from 'path';
-import { GENERATOR_ANGULAR, GENERATOR_COMMON, GENERATOR_GIT, GENERATOR_WORKSPACES } from '../generator-list.mjs';
-import { GENERATOR_JHIPSTER } from '../generator-constants.mjs';
-import BaseGenerator from '../base/index.mjs';
-import { getConfigWithDefaults } from '../../jdl/jhipster/index.mjs';
-import { removeFieldsWithNullishValues } from '../base/support/config.mjs';
+import { existsSync } from 'fs';
+import { GENERATOR_ANGULAR, GENERATOR_BOOTSTRAP_WORKSPACES, GENERATOR_GIT, GENERATOR_WORKSPACES } from '../generator-list.mjs';
+import BaseWorkspacesGenerator from '../base-workspaces/index.mjs';
 import command from './command.mjs';
 /**
  * Base class for a generator that can be extended through a blueprint.
  *
  * @class
- * @extends {BaseGenerator}
+ * @extends {BaseWorkspacesGenerator}
  */
-export default class WorkspacesGenerator extends BaseGenerator {
-    workspacesFolders;
+export default class WorkspacesGenerator extends BaseWorkspacesGenerator {
     workspaces;
     generateApplications;
     generateWith;
     generateWorkspaces;
     async beforeQueue() {
+        await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_WORKSPACES, { generatorOptions: { customWorkspacesConfig: true } });
         if (!this.fromBlueprint) {
             await this.composeWithBlueprints(GENERATOR_WORKSPACES);
         }
-        this.loadRuntimeOptions();
     }
     get initializing() {
-        return {
+        return this.asInitializingTaskGroup({
             loadConfig() {
                 this.parseJHipsterOptions(command.options);
                 // Generate workspaces file only when option passed or regenerating
-                this.generateWorkspaces = this.workspaces !== false || !!this.packageJson.get('workspaces');
+                this.generateWorkspaces = this.workspaces !== false || !!this.packageJson?.get('workspaces');
                 // When generating workspaces, save to .yo-rc.json. Use a dummy config otherwise.
                 this.workspacesConfig = this.generateWorkspaces ? this.jhipsterConfig : {};
             },
-        };
+        });
     }
-    get [BaseGenerator.INITIALIZING]() {
+    get [BaseWorkspacesGenerator.INITIALIZING]() {
         return this.delegateTasksToBlueprint(() => this.initializing);
     }
     get configuring() {
-        return {
+        return this.asConfiguringTaskGroup({
             async configure() {
                 this.jhipsterConfig.baseName = this.jhipsterConfig.baseName || 'workspaces';
             },
-        };
+            async configureUsingFiles() {
+                if (!this.generateWorkspaces)
+                    return;
+                if (existsSync(this.destinationPath('docker-compose'))) {
+                    this.workspacesConfig.dockerCompose = true;
+                }
+                this.workspacesConfig.appsFolders = [...new Set([...(this.workspacesConfig.packages ?? []), ...this.appsFolders])];
+                delete this.workspacesConfig.packages;
+            },
+        });
     }
-    get [BaseGenerator.CONFIGURING]() {
+    get [BaseWorkspacesGenerator.CONFIGURING]() {
         return this.delegateTasksToBlueprint(() => this.configuring);
     }
     get composing() {
-        return {
+        return this.asComposingTaskGroup({
             async composeGit() {
                 if (this.options.monorepository || this.jhipsterConfig.monorepository) {
                     await this.composeWithJHipster(GENERATOR_GIT);
                 }
             },
-        };
-    }
-    get [BaseGenerator.COMPOSING]() {
-        return this.delegateTasksToBlueprint(() => this.composing);
-    }
-    get default() {
-        return {
             async generateApplications() {
                 if (!this.generateApplications) {
                     return;
@@ -88,77 +85,58 @@ export default class WorkspacesGenerator extends BaseGenerator {
                     await this.generateApplications.call(this);
                 }
                 else {
-                    for (const appName of this.workspacesFolders) {
+                    for (const appName of this.appsFolders) {
                         await this.composeWithJHipster(this.generateWith, { generatorOptions: { destinationRoot: this.destinationPath(appName) } });
                     }
                 }
             },
-            async configureUsingFiles() {
-                if (!this.generateWorkspaces)
-                    return;
-                const packages = [...(this.workspacesConfig.packages ?? [])];
-                this.workspacesFolders.forEach(workspace => !packages.includes(workspace) && packages.push(workspace));
-                let dockerCompose;
-                const dir = fs.opendirSync('./');
-                let dirent = await dir.read();
-                while (dirent) {
-                    if (dirent.isDirectory()) {
-                        if (dirent.name === 'docker-compose') {
-                            dockerCompose = true;
-                        }
-                        else if (fs.existsSync(path.join(dir.path, dirent.name, 'package.json'))) {
-                            if (!packages.includes(dirent.name)) {
-                                packages.push(dirent.name);
-                            }
-                        }
-                    }
-                    dirent = await dir.read();
-                }
-                dir.closeSync();
-                this.workspacesConfig.dockerCompose = dockerCompose;
-                this.workspacesConfig.packages = packages;
-            },
-            configurePackageManager() {
+        });
+    }
+    get [BaseWorkspacesGenerator.COMPOSING]() {
+        return this.delegateTasksToBlueprint(() => this.composing);
+    }
+    get loadingWorkspaces() {
+        return this.asDefaultTaskGroup({
+            configurePackageManager({ applications }) {
                 if (this.workspacesConfig.clientPackageManager || !this.generateWorkspaces)
                     return;
-                this.workspacesConfig.clientPackageManager = this._detectNodePackageManager();
+                this.workspacesConfig.clientPackageManager =
+                    this.options.clientPackageManager ?? applications.find(app => app.clientPackageManager)?.clientPackageManager ?? 'npm';
             },
             async loadConfig() {
                 if (!this.generateWorkspaces)
                     return;
                 this.dockerCompose = this.workspacesConfig.dockerCompose;
-                this.packages = this.workspacesConfig.packages;
                 this.env.options.nodePackageManager = this.workspacesConfig.clientPackageManager;
             },
-        };
+        });
     }
-    get [BaseGenerator.DEFAULT]() {
-        return this.delegateTasksToBlueprint(() => this.default);
+    get [BaseWorkspacesGenerator.LOADING_WORKSPACES]() {
+        return this.delegateTasksToBlueprint(() => this.loadingWorkspaces);
     }
     get postWriting() {
-        return {
-            generatePackageJson() {
+        return this.asPostWritingTaskGroup({
+            generatePackageJson({ applications }) {
                 if (!this.generateWorkspaces)
                     return;
-                const { dependencies: { rxjs }, devDependencies: { webpack: webpackVersion }, } = this.fs.readJSON(this.fetchFromInstalledJHipster(GENERATOR_ANGULAR, 'resources', 'package.json'));
-                const { devDependencies: { concurrently }, } = this.fs.readJSON(this.fetchFromInstalledJHipster(GENERATOR_COMMON, 'resources', 'package.json'));
+                const findDependencyVersion = dependency => applications.find(app => app.nodeDependencies[dependency])?.nodeDependencies[dependency];
                 this.packageJson.merge({
                     workspaces: {
-                        packages: this.packages,
+                        packages: this.appsFolders,
                     },
                     devDependencies: {
-                        concurrently,
+                        concurrently: findDependencyVersion('concurrently'),
                     },
                     scripts: {
                         'ci:e2e:package': 'npm run ci:docker:build --workspaces --if-present && npm run java:docker --workspaces --if-present',
                         'ci:e2e:run': 'npm run e2e:headless --workspaces --if-present',
-                        ...this._getOtherScripts(),
-                        ...this._createConcurrentlyScript('watch', 'backend:build-cache', 'java:docker', 'java:docker:arm64'),
-                        ...this._createWorkspacesScript('ci:backend:test', 'ci:frontend:test', 'webapp:test'),
+                        ...this.getOtherScripts(),
+                        ...this.createConcurrentlyScript('watch', 'backend:build-cache', 'java:docker', 'java:docker:arm64'),
+                        ...this.createWorkspacesScript('ci:backend:test', 'ci:frontend:test', 'webapp:test'),
                     },
                 });
-                const applications = this.loadApplications();
                 if (applications.some(app => app.clientFrameworkAngular)) {
+                    const { dependencies: { rxjs }, devDependencies: { webpack: webpackVersion }, } = this.fs.readJSON(this.fetchFromInstalledJHipster(GENERATOR_ANGULAR, 'resources', 'package.json'));
                     this.packageJson.merge({
                         devDependencies: {
                             rxjs, // Set version to workaround https://github.com/npm/cli/issues/4437
@@ -168,36 +146,13 @@ export default class WorkspacesGenerator extends BaseGenerator {
                         },
                     });
                 }
-                if (applications.some(app => app.clientFrameworkVue)) {
-                    this.packageJson.merge({
-                        // https://github.com/vuejs/vue-jest/issues/480#issuecomment-1330479635
-                        overrides: {
-                            '@babel/core': '7.17.9',
-                            '@babel/generator': '7.17.9',
-                            'istanbul-lib-instrument': '5.2.0',
-                        },
-                    });
-                }
             },
-        };
+        });
     }
-    get [BaseGenerator.POST_WRITING]() {
+    get [BaseWorkspacesGenerator.POST_WRITING]() {
         return this.delegateTasksToBlueprint(() => this.postWriting);
     }
-    _detectNodePackageManager() {
-        if (this.options.clientPackageManager !== undefined) {
-            return this.options.clientPackageManager;
-        }
-        if (this.workspacesConfig.packages && this.workspacesConfig.packages.length > 0) {
-            const appPackageJson = this.readDestinationJSON(`${this.workspacesConfig.packages[0]}/.yo-rc.json`);
-            const nodePackageManager = appPackageJson && appPackageJson[GENERATOR_JHIPSTER] && appPackageJson[GENERATOR_JHIPSTER].clientPackageManager;
-            if (nodePackageManager) {
-                return nodePackageManager;
-            }
-        }
-        return 'npm';
-    }
-    _getOtherScripts() {
+    getOtherScripts() {
         if (this.dockerCompose) {
             return {
                 'docker-compose': 'docker compose -f docker-compose/docker-compose.yml up --wait',
@@ -207,39 +162,20 @@ export default class WorkspacesGenerator extends BaseGenerator {
         }
         return {};
     }
-    _createConcurrentlyScript(...scripts) {
+    createConcurrentlyScript(...scripts) {
         const scriptsList = scripts
             .map(script => {
-            const packageScripts = this.packages.map(packageName => [
+            const packageScripts = this.appsFolders.map(packageName => [
                 `${script}:${packageName}`,
                 `npm run ${script} --workspace ${packageName} --if-present`,
             ]);
-            packageScripts.push([script, `concurrently ${this.packages.map(packageName => `npm:${script}:${packageName}`).join(' ')}`]);
+            packageScripts.push([script, `concurrently ${this.appsFolders.map(packageName => `npm:${script}:${packageName}`).join(' ')}`]);
             return packageScripts;
         })
             .flat();
         return Object.fromEntries(scriptsList);
     }
-    _createWorkspacesScript(...scripts) {
+    createWorkspacesScript(...scripts) {
         return Object.fromEntries(scripts.map(script => [`${script}`, `npm run ${script} --workspaces --if-present`]));
     }
-    loadApplications() {
-        return this.workspacesConfig.packages
-            .map(appPath => {
-            const appConfig = this.readDestinationJSON(`${appPath}/.yo-rc.json`)[GENERATOR_JHIPSTER];
-            if (!appConfig)
-                return undefined;
-            const app = getConfigWithDefaults(removeFieldsWithNullishValues(appConfig));
-            this.loadAppConfig(app, app);
-            this.loadServerConfig(app, app);
-            this.loadClientConfig(app, app);
-            this.loadPlatformConfig(app, app);
-            this.loadDerivedAppConfig(app);
-            this.loadDerivedClientConfig(app);
-            this.loadDerivedServerConfig(app);
-            this.loadDerivedPlatformConfig(app);
-            return app;
-        })
-            .filter(app => app);
-    }
 }

package/dist/jdl/converters/json-to-jdl-converter.js

@@ -25,8 +25,8 @@ import { readJSONFile } from '../readers/json-file-reader.js';
 import { convertApplicationToJDL } from './json-to-jdl-application-converter.js';
 import { convertEntitiesToJDL } from './json-to-jdl-entity-converter.js';
 import exportJDLObject from '../exporters/jdl-exporter.js';
-import ApplicationOptions from '../jhipster/application-options.js';
-const { OptionNames } = ApplicationOptions;
+import { removeFieldsWithNullishValues } from '../../generators/base/support/config.mjs';
+import { GENERATOR_JHIPSTER } from '../../generators/generator-constants.mjs';
 export default {
     convertToJDL,
     convertSingleContentToJDL,
@@ -93,13 +93,15 @@ function getJDLObjectFromSingleApplication(yoRcFileContent, entities, existingJD
     return mergeJDLObjects(existingJDLObject, jdlObject);
 }
 function cleanYoRcFileContent(yoRcFileContent) {
-    const [generatorName] = Object.keys(yoRcFileContent);
-    delete yoRcFileContent[generatorName].promptValues;
-    if (yoRcFileContent[generatorName].blueprints) {
-        yoRcFileContent[generatorName].blueprints = yoRcFileContent[generatorName].blueprints.map(blueprint => blueprint.name);
+    for (const key of Object.keys(yoRcFileContent)) {
+        yoRcFileContent[key] = removeFieldsWithNullishValues(yoRcFileContent[key]);
     }
-    if (yoRcFileContent[generatorName].microfrontends) {
-        yoRcFileContent[generatorName].microfrontends = yoRcFileContent[generatorName].microfrontends.map(({ baseName }) => baseName);
+    delete yoRcFileContent[GENERATOR_JHIPSTER].promptValues;
+    if (yoRcFileContent[GENERATOR_JHIPSTER].blueprints) {
+        yoRcFileContent[GENERATOR_JHIPSTER].blueprints = yoRcFileContent[GENERATOR_JHIPSTER].blueprints.map(blueprint => blueprint.name);
+    }
+    if (yoRcFileContent[GENERATOR_JHIPSTER].microfrontends) {
+        yoRcFileContent[GENERATOR_JHIPSTER].microfrontends = yoRcFileContent[GENERATOR_JHIPSTER].microfrontends.map(({ baseName }) => baseName);
     }
     return yoRcFileContent;
 }

package/dist/jdl/converters/parsed-jdl-to-jdl-object/application-converter.js

@@ -24,10 +24,9 @@ export default { convertApplications };
 /**
  * Converts parsed applications to JDL applications.
  * @param {Array<Object>} parsedApplications - the parsed applications.
- * @param {Object} configuration - a configuration object.
  * @return {Array} the converted JDL applications.
  */
-export function convertApplications(parsedApplications, configuration = {}) {
+export function convertApplications(parsedApplications) {
     if (!parsedApplications) {
         throw new Error('Applications have to be passed so as to be converted.');
     }

package/dist/jdl/exporters/jhipster-entity-exporter.js

@@ -16,19 +16,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import fs from 'fs';
 import path from 'path';
 import { applicationTypes } from '../jhipster/index.mjs';
 import { toFilePath, readJSONFile } from '../readers/json-file-reader.js';
-import { createFolderIfItDoesNotExist, doesFileExist } from '../utils/file-utils.js';
-import { areEntitiesEqual } from '../utils/object-utils.js';
+import { doesFileExist } from '../utils/file-utils.js';
 let configuration = {};
 /**
  * Exports the passed entities to JSON.
  * @param {Object} passedConfiguration - the object having the keys:
  * @param {Array<JSONEntity>} passedConfiguration.entities - the entity objects to export.
- * @param {Boolean} passedConfiguration.forceNoFiltering - whether to filter out unchanged entities.
- * @param {Boolean} passedConfiguration.skipFileGeneration - whether to skip file write to disk.
  * @param {Object} passedConfiguration.application - the application where the entities should be exported.
  * @param {Boolean} passedConfiguration.application.forSeveralApplications - whether to create the .jhipster folder
  *          inside a specific application's folder.
@@ -43,16 +39,9 @@ export default function exportEntities(passedConfiguration) {
     }
     const subFolder = passedConfiguration.application.forSeveralApplications ? configuration.application.name : '';
     configuration.entities = updateEntities(subFolder);
-    if (!configuration.forceNoFiltering) {
-        configuration.entities = filterOutUnchangedEntities(subFolder);
-    }
     if (shouldFilterOutEntitiesBasedOnMicroservice()) {
         configuration.entities = filterOutEntitiesByMicroservice();
     }
-    if (!passedConfiguration.skipFileGeneration) {
-        createJHipsterJSONFolder(subFolder);
-        writeEntities(subFolder);
-    }
     return configuration.entities;
 }
 function init(passedConfiguration) {
@@ -61,13 +50,6 @@ function init(passedConfiguration) {
     }
     configuration = passedConfiguration;
 }
-/**
- * Creates the JHipster entity folder, if possible.
- * @param subFolder the folder (to create) in which the JHipster entity folder will be.
- */
-function createJHipsterJSONFolder(subFolder) {
-    createFolderIfItDoesNotExist(path.join(subFolder, '.jhipster'));
-}
 /**
  * Writes entities in a sub folder.
  * @param subFolder the folder (to create) in which the JHipster entity folder will be.
@@ -78,16 +60,6 @@ function updateEntities(subFolder) {
         return updateEntityToGenerateWithExistingOne(filePath, entity);
     });
 }
-/**
- * Writes entities in a sub folder.
- * @param subFolder the folder (to create) in which the JHipster entity folder will be.
- */
-function writeEntities(subFolder) {
-    configuration.entities.forEach(entity => {
-        const filePath = path.join(subFolder, toFilePath(entity.name));
-        fs.writeFileSync(filePath, JSON.stringify(entity, null, 2).concat('\n'));
-    });
-}
 function updateEntityToGenerateWithExistingOne(filePath, entity) {
     if (doesFileExist(filePath)) {
         const fileOnDisk = readJSONFile(filePath);
@@ -98,12 +70,6 @@ function updateEntityToGenerateWithExistingOne(filePath, entity) {
     }
     return entity;
 }
-function filterOutUnchangedEntities(subFolder) {
-    return configuration.entities.filter(entity => {
-        const filePath = path.join(subFolder, toFilePath(entity.name));
-        return !(doesFileExist(filePath) && areEntitiesEqual(readJSONFile(filePath), entity));
-    });
-}
 function shouldFilterOutEntitiesBasedOnMicroservice() {
     return (configuration.application.type && configuration.application.type === applicationTypes.MICROSERVICE && configuration.application.name);
 }

package/dist/jdl/index.js

@@ -0,0 +1,3 @@
+export * from './jdl-importer.js';
+export * from './parsing/api.js';
+export * from './jhipster/index.mjs';

package/dist/jdl/jdl-importer.js

@@ -23,7 +23,6 @@ import { readJSONFile } from './readers/json-file-reader.js';
 import { doesFileExist } from './utils/file-utils.js';
 import JDLWithoutApplicationToJSONConverter from './converters/jdl-to-json/jdl-without-application-to-json-converter.js';
 import { convert } from './converters/jdl-to-json/jdl-with-applications-to-json-converter.js';
-import { exportApplication, exportApplications } from './exporters/applications/jhipster-application-exporter.js';
 import { formatApplicationToExport, formatApplicationsToExport } from './exporters/applications/jhipster-application-formatter.js';
 import exportDeployments from './exporters/jhipster-deployment-exporter.js';
 import exportEntities from './exporters/jhipster-entity-exporter.js';
@@ -45,8 +44,6 @@ const { uniqBy } = _;
  * @param {String} configuration.applicationName - deprecated, the application's name, optional if parsing applications
  * @param {String} configuration.applicationType - deprecated, the application type, optional if parsing applications
  * @param {String} configuration.databaseType - deprecated, the database type, optional if parsing applications
- * @param {String} configuration.forceNoFiltering - whether to force filtering
- * @param {Boolean} configuration.skipFileGeneration - whether not to generate the .yo-rc.json file
  * @returns {Object} a JDL importer.
  * @throws {Error} if files aren't passed.
  */
@@ -69,8 +66,6 @@ export function createImporterFromFiles(files, configuration) {
  * @param {String} configuration.applicationName - deprecated, the application's name, optional if parsing applications
  * @param {String} configuration.applicationType - deprecated, the application type, optional if parsing applications
  * @param {String} configuration.databaseType - deprecated, the database type, optional if parsing applications
- * @param {String} configuration.forceNoFiltering - whether to force filtering
- * @param {Boolean} configuration.skipFileGeneration - whether not to generate the .yo-rc.json file
  * @param {Array} configuration.blueprints - the blueprints used.
  * @returns {Object} a JDL importer.
  * @throws {Error} if the content isn't passed.
@@ -195,7 +190,6 @@ function importOnlyEntities(jdlObject, configuration) {
     return exportJSONEntities(jsonEntities, configuration);
 }
 function importOneApplicationAndEntities(jdlObject, configuration) {
-    const { skipFileGeneration, forceNoFiltering } = configuration;
     const importState = {
         exportedApplications: [],
         exportedApplicationsWithEntities: {},
@@ -203,9 +197,6 @@ function importOneApplicationAndEntities(jdlObject, configuration) {
         exportedDeployments: [],
     };
     const formattedApplication = formatApplicationToExport(jdlObject.getApplications()[0], configuration);
-    if (!skipFileGeneration) {
-        exportApplication(formattedApplication);
-    }
     importState.exportedApplications.push(formattedApplication);
     const jdlApplication = jdlObject.getApplications()[0];
     const applicationName = jdlApplication.getConfigurationOptionValue(BASE_NAME);
@@ -222,8 +213,6 @@ function importOneApplicationAndEntities(jdlObject, configuration) {
             applicationName,
             applicationType: jdlApplication.getConfigurationOptionValue(APPLICATION_TYPE),
             forSeveralApplications: false,
-            skipFileGeneration,
-            forceNoFiltering,
         });
         importState.exportedApplicationsWithEntities[applicationName].entities = exportedJSONEntities;
         importState.exportedEntities = uniqBy([...importState.exportedEntities, ...exportedJSONEntities], 'name');
@@ -231,7 +220,6 @@ function importOneApplicationAndEntities(jdlObject, configuration) {
     return importState;
 }
 function importApplicationsAndEntities(jdlObject, configuration) {
-    const { skipFileGeneration, forceNoFiltering } = configuration;
     const importState = {
         exportedApplications: [],
         exportedApplicationsWithEntities: {},
@@ -240,9 +228,6 @@ function importApplicationsAndEntities(jdlObject, configuration) {
     };
     const formattedApplications = formatApplicationsToExport(jdlObject.applications, configuration);
     importState.exportedApplications = formattedApplications;
-    if (!skipFileGeneration) {
-        exportApplications(formattedApplications);
-    }
     const entitiesPerApplicationMap = convert({
         jdlObject,
     });
@@ -252,8 +237,6 @@ function importApplicationsAndEntities(jdlObject, configuration) {
             applicationName,
             applicationType: jdlApplication.getConfigurationOptionValue(APPLICATION_TYPE),
             forSeveralApplications: true,
-            skipFileGeneration,
-            forceNoFiltering,
         });
         const exportedConfig = importState.exportedApplications.find(config => applicationName === config['generator-jhipster'].baseName);
         importState.exportedApplicationsWithEntities[applicationName] = {
@@ -268,7 +251,6 @@ function importDeployments(deployments) {
     return exportDeployments(deployments);
 }
 function exportJSONEntities(entities, configuration) {
-    const { forceNoFiltering, skipFileGeneration } = configuration;
     let baseName = configuration.applicationName;
     let applicationType = configuration.applicationType;
     if (configuration.application) {
@@ -277,8 +259,6 @@ function exportJSONEntities(entities, configuration) {
     }
     return exportEntities({
         entities,
-        forceNoFiltering,
-        skipFileGeneration,
         application: {
             name: baseName,
             type: applicationType,
@@ -286,7 +266,3 @@ function exportJSONEntities(entities, configuration) {
         },
     });
 }
-export default {
-    createImporterFromContent,
-    createImporterFromFiles,
-};

package/dist/jdl/jhipster/default-application-options.js

@@ -27,7 +27,7 @@ import buildToolTypes from './build-tool-types.js';
 import { MESSAGE_BROKER, MESSAGE_BROKER_NO } from '../../generators/server/options/index.mjs';
 const { MONOLITH, MICROSERVICE, GATEWAY } = applicationTypes;
 const { CONSUL } = serviceDiscoveryTypes;
-const { COUCHBASE, CASSANDRA, MONGODB, NEO4J, SQL, H2_DISK, POSTGRESQL } = databaseTypes;
+const { COUCHBASE, CASSANDRA, MONGODB, NEO4J, SQL, POSTGRESQL } = databaseTypes;
 const NO_DATABASE_TYPE = databaseTypes.NO;
 const { OptionNames, OptionValues } = applicationOptions;
 const { JWT, OAUTH2 } = authenticationTypes;
@@ -131,7 +131,7 @@ export function getConfigForDatabaseType(options = {}) {
             options[PROD_DATABASE_TYPE] = POSTGRESQL;
         }
         if (options[DEV_DATABASE_TYPE] === undefined) {
-            options[DEV_DATABASE_TYPE] = H2_DISK;
+            options[DEV_DATABASE_TYPE] = options[PROD_DATABASE_TYPE];
         }
     }
     else if ([MONGODB, COUCHBASE, CASSANDRA, NEO4J, NO_DATABASE_TYPE].includes(options[DATABASE_TYPE])) {

package/dist/jdl/jhipster/deployment-options.js

@@ -103,9 +103,9 @@ const Options = {
 Options.defaults = (deploymentType = Options.deploymentType.dockerCompose) => {
     if (deploymentType === Options.deploymentType.kubernetes) {
         return {
-            appsFolders: new Set(),
+            appsFolders: [],
             directoryPath: Options.directoryPath,
-            clusteredDbApps: new Set(),
+            clusteredDbApps: [],
             serviceDiscoveryType: Options.serviceDiscoveryType.consul,
             dockerRepositoryName: Options.dockerRepositoryName,
             dockerPushCommand: Options.dockerPushCommand,
@@ -120,18 +120,18 @@ Options.defaults = (deploymentType = Options.deploymentType.dockerCompose) => {
     }
     if (deploymentType === Options.deploymentType.dockerCompose) {
         return {
-            appsFolders: new Set(),
+            appsFolders: [],
             directoryPath: Options.directoryPath,
             gatewayType: Options.gatewayType.springCloudGateway,
-            clusteredDbApps: new Set(),
+            clusteredDbApps: [],
             monitoring: Options.monitoring.no,
             serviceDiscoveryType: Options.serviceDiscoveryType.consul,
         };
     }
     return {
-        appsFolders: new Set(),
+        appsFolders: [],
         directoryPath: Options.directoryPath,
-        clusteredDbApps: new Set(),
+        clusteredDbApps: [],
         serviceDiscoveryType: Options.serviceDiscoveryType.consul,
         monitoring: Options.monitoring.no,
         dockerRepositoryName: Options.dockerRepositoryName,

package/dist/jdl/models/jdl-application-configuration.js

@@ -20,7 +20,7 @@ import ApplicationOptions from '../jhipster/application-options.js';
 const { OptionNames } = ApplicationOptions;
 export default class JDLApplicationConfiguration {
     options;
-    constructor(config = {}) {
+    constructor() {
         this.options = {};
     }
     hasOption(optionName) {

package/dist/jdl/parsing/generated/generated-serialized-grammar.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/* eslint-disable no-unused-vars */
+/* eslint-disable unused-imports/no-unused-vars */
 const serializedGrammar = [
     {
         type: 'Rule',

package/dist/jdl/parsing/self-checks/token-collector-visitor.js

@@ -18,13 +18,13 @@
  */
 import { GAstVisitor } from 'chevrotain';
 export default class TokenCollectorVisitor extends GAstVisitor {
-    visitNonTerminal(node) { }
-    visitAlternative(node) { }
-    visitOption(node) { }
-    visitRepetition(node) { }
-    visitRepetitionMandatory(node) { }
-    visitAlternation(node) { }
-    visitRule(node) { }
+    visitNonTerminal(_node) { }
+    visitAlternative(_node) { }
+    visitOption(_node) { }
+    visitRepetition(_node) { }
+    visitRepetitionMandatory(_node) { }
+    visitAlternation(_node) { }
+    visitRule(_node) { }
     actualTokens;
     constructor() {
         super();

package/dist/jdl/readers/json-reader.js

@@ -20,10 +20,8 @@ import fs from 'fs';
 import { convertEntitiesToJDL } from '../converters/json-to-jdl-entity-converter.js';
 import { convertServerOptionsToJDL } from '../converters/json-to-jdl-option-converter.js';
 import mergeJDLObjects from '../models/jdl-object-merger.js';
-import { applicationOptions } from '../jhipster/index.mjs';
 import { doesDirectoryExist } from '../utils/file-utils.js';
 import { readJSONFile } from './json-file-reader.js';
-const { OptionNames } = applicationOptions;
 /* Parse the given jhipster app dir and return a JDLObject */
 export default function parseFromDir(dir) {
     if (!dir) {

package/dist/jdl/validators/jdl-with-application-validator.js

@@ -50,7 +50,7 @@ export default function createValidator(jdlObject, logger = console) {
                 checkForRelationshipErrors();
                 checkForEnumErrors();
                 checkDeploymentsErrors();
-                checkForOptionErrors(jdlApplication);
+                checkForOptionErrors();
             });
             checkForRelationshipsBetweenApplications();
         },
@@ -68,7 +68,7 @@ export default function createValidator(jdlObject, logger = console) {
             checkForFieldErrors(jdlEntity.name, jdlEntity.fields, jdlApplication);
         });
     }
-    function checkForFieldErrors(entityName, jdlFields, jdlApplication) {
+    function checkForFieldErrors(_entityName, jdlFields, _jdlApplication) {
         const validator = new FieldValidator();
         Object.keys(jdlFields).forEach(fieldName => {
             const jdlField = jdlFields[fieldName];
@@ -118,7 +118,7 @@ export default function createValidator(jdlObject, logger = console) {
             validator.validate(deployment);
         });
     }
-    function checkForOptionErrors(jdlApplication) {
+    function checkForOptionErrors() {
         if (jdlObject.getOptionQuantity() === 0) {
             return;
         }