generator-jhipster 8.1.0 → 8.2.0

package/dist/generators/java/templates/src/test/java/_package_/domain/AssertUtils.java.ejs

@@ -0,0 +1,34 @@
+<%#
+ Copyright 2013-2024 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.domain;
+
+import java.math.BigDecimal;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.util.Comparator;
+
+public class AssertUtils {
+
+    public static Comparator<ZonedDateTime> zonedDataTimeSameInstant = Comparator.nullsFirst((e1, a2) ->
+        e1.withZoneSameInstant(ZoneOffset.UTC).compareTo(a2.withZoneSameInstant(ZoneOffset.UTC))
+    );
+
+    public static Comparator<BigDecimal> bigDecimalCompareTo = Comparator.nullsFirst((e1, a2) -> e1.compareTo(a2));
+
+}

package/dist/generators/jdl/command.js

@@ -0,0 +1,53 @@
+import { GENERATOR_WORKSPACES } from '../generator-list.js';
+const command = {
+    arguments: {
+        jdlFiles: {
+            type: Array,
+        },
+    },
+    options: {
+        entrypointGenerator: {
+            description: 'Entrypoint generator to be used',
+            type: String,
+            scope: 'generator',
+            hide: true,
+        },
+        interactive: {
+            description: 'Generate multiple applications in series so that questions can be interacted with. This is the default when there is an existing application configuration in any of the folders',
+            type: Boolean,
+            scope: 'generator',
+        },
+        jsonOnly: {
+            description: 'Generate only the JSON files and skip entity regeneration',
+            type: Boolean,
+            scope: 'generator',
+        },
+        ignoreApplication: {
+            description: 'Ignores application generation',
+            type: Boolean,
+            scope: 'generator',
+        },
+        ignoreDeployments: {
+            description: 'Ignores deployments generation',
+            type: Boolean,
+            scope: 'generator',
+        },
+        skipSampleRepository: {
+            description: 'Disable fetching sample files when the file is not a URL',
+            type: Boolean,
+            scope: 'generator',
+        },
+        inline: {
+            description: 'Pass JDL content inline. Argument can be skipped when passing this',
+            type: String,
+            scope: 'generator',
+        },
+        skipUserManagement: {
+            description: 'Skip the user management module during app generation',
+            type: Boolean,
+            scope: 'generator',
+        },
+    },
+    import: [GENERATOR_WORKSPACES],
+};
+export default command;

package/dist/generators/jdl/generator.js

@@ -0,0 +1,298 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { extname } from 'path';
+import * as _ from 'lodash-es';
+import { create as createMemFs } from 'mem-fs';
+import { create as createMemFsEditor } from 'mem-fs-editor';
+import { readFile } from 'fs/promises';
+import BaseGenerator from '../base/index.js';
+import command from './command.js';
+import { downloadJdlFile } from '../../cli/download.mjs';
+import EnvironmentBuilder from '../../cli/environment-builder.mjs';
+import { CLI_NAME } from '../../cli/utils.mjs';
+import { GENERATOR_APP, GENERATOR_ENTITIES, GENERATOR_WORKSPACES } from '../generator-list.js';
+import { createImporterFromContent } from '../../jdl/jdl-importer.js';
+import { GENERATOR_JHIPSTER, JHIPSTER_CONFIG_DIR } from '../generator-constants.js';
+import statistics from '../statistics.js';
+import { addApplicationIndex, allNewApplications, customizeForMicroservices } from './internal/index.js';
+import { mergeYoRcContent } from '../../jdl/index.js';
+import { normalizeBlueprintName } from '../base/internal/blueprint.js';
+import { updateApplicationEntitiesTransform } from '../base-application/support/update-application-entities-transform.js';
+const { upperFirst } = _;
+/**
+ * Add jdl extension to the file
+ */
+const toJdlFile = file => {
+    if (!extname(file)) {
+        return `${file}.jdl`;
+    }
+    return file;
+};
+export default class JdlGenerator extends BaseGenerator {
+    jdlFiles;
+    inline;
+    jdlContents = [];
+    entrypointGenerator = `${CLI_NAME}:${GENERATOR_APP}`;
+    entitiesGenerator = GENERATOR_ENTITIES;
+    workspacesGenerator = GENERATOR_WORKSPACES;
+    interactive;
+    jsonOnly;
+    ignoreApplication;
+    ignoreDeployments;
+    skipSampleRepository;
+    force;
+    reproducible;
+    createEnvBuilder = EnvironmentBuilder.createDefaultBuilder;
+    existingProject;
+    applications;
+    exportedApplicationsWithEntities;
+    exportedEntities;
+    exportedDeployments;
+    async beforeQueue() {
+        if (!this.fromBlueprint) {
+            await this.composeWithBlueprints('jdl');
+        }
+    }
+    get initializing() {
+        return this.asInitializingTaskGroup({
+            loadArguments() {
+                this.parseJHipsterArguments(command.arguments);
+                if (this.jdlFiles) {
+                    this.log.verboseInfo('Generating jdls', ...this.jdlFiles);
+                }
+            },
+            loadOptions() {
+                this.parseJHipsterOptions(command.options);
+            },
+            existingProject() {
+                this.existingProject = this.jhipsterConfig.baseName !== undefined && this.config.existed;
+            },
+            checkOptions() {
+                if (!this.inline && !this.jdlFiles?.length) {
+                    throw new Error('At least one jdl file is required.');
+                }
+            },
+        });
+    }
+    get [BaseGenerator.INITIALIZING]() {
+        return this.delegateTasksToBlueprint(() => this.initializing);
+    }
+    get configuring() {
+        return this.asConfiguringTaskGroup({
+            insight() {
+                statistics.sendSubGenEvent('generator', 'import-jdl');
+            },
+            async downloadJdlFiles() {
+                if (this.jdlFiles) {
+                    this.jdlFiles = await Promise.all(this.jdlFiles.map(toJdlFile).map(async (filename) => {
+                        try {
+                            this.readDestination(filename);
+                        }
+                        catch {
+                            this.log.warn(`File not found: ${filename}. Attempting download from jdl-samples repository`);
+                            const downloadedFile = await downloadJdlFile(filename, { skipSampleRepository: this.skipSampleRepository });
+                            // The file has null content at mem-fs, update with actual content.
+                            this.writeDestination(downloadedFile, (await readFile(downloadedFile)).toString());
+                            return downloadedFile;
+                        }
+                        return filename;
+                    }));
+                }
+            },
+            readJdlFiles() {
+                if (this.inline) {
+                    this.jdlContents.push(this.inline);
+                }
+                for (const jdlFile of this.jdlFiles ?? []) {
+                    this.jdlContents.push(this.readDestination(jdlFile)?.toString() ?? '');
+                }
+            },
+            async parseJDL() {
+                const configuration = {
+                    applicationName: this.options.baseName ?? (this.existingProject ? this.jhipsterConfig.baseName : undefined),
+                    databaseType: this.options.db ?? (this.existingProject ? this.jhipsterConfigWithDefaults.prodDatabaseType : undefined),
+                    applicationType: this.options.applicationType,
+                    skipUserManagement: this.options.skipUserManagement,
+                };
+                const importer = createImporterFromContent(this.jdlContents.join('\n'), configuration);
+                const importState = importer.import();
+                this.exportedDeployments = importState.exportedDeployments;
+                this.exportedEntities = importState.exportedEntities;
+                this.exportedApplicationsWithEntities = importState.exportedApplicationsWithEntities;
+                const applicationsWithEntities = Object.values(importState.exportedApplicationsWithEntities);
+                this.applications =
+                    applicationsWithEntities.length === 1
+                        ? applicationsWithEntities
+                        : [
+                            ...applicationsWithEntities.filter((app) => app.config.applicationType === 'gateway'),
+                            ...applicationsWithEntities.filter((app) => app.config.applicationType !== 'gateway'),
+                        ];
+            },
+            configure() {
+                const nrApplications = this.applications.length;
+                const allNew = allNewApplications(this.applications);
+                const interactiveFallback = !allNew;
+                this.interactive = this.interactive ?? interactiveFallback;
+                this.force = this.options.force ?? (nrApplications > 0 && allNew) ? true : undefined;
+                this.reproducible = allNew;
+            },
+            customizeApplication() {
+                for (const app of this.applications) {
+                    app.config.entities = app.entities.map(entity => entity.name);
+                }
+                if (this.applications.length > 1) {
+                    for (const app of this.applications) {
+                        app.folder = app.config.baseName;
+                        if (!this.interactive && !this.jsonOnly && !this.ignoreApplication) {
+                            app.sharedFs = createMemFs();
+                        }
+                    }
+                }
+                addApplicationIndex(this.applications);
+                customizeForMicroservices(this.exportedApplicationsWithEntities);
+            },
+            async generateJson() {
+                if (this.applications.length === 0) {
+                    this.writeConfig({ entities: this.exportedEntities });
+                    await this.env.sharedFs.pipeline({ refresh: true }, updateApplicationEntitiesTransform({ destinationPath: this.destinationPath(), throwOnMissingConfig: false }));
+                }
+                else {
+                    this.writeConfig(...this.applications.map(app => (this.ignoreApplication ? { ...app, config: undefined } : app)));
+                }
+            },
+            async generate() {
+                if (this.jsonOnly) {
+                    return;
+                }
+                const generatorOptions = { defaults: true, reproducible: this.options.reproducible ?? this.reproducible, force: this.force };
+                if (this.ignoreApplication || this.applications.length === 0) {
+                    if (this.applications.length === 0) {
+                        const entities = this.exportedEntities;
+                        await this.composeWithJHipster(this.entitiesGenerator, {
+                            generatorArgs: entities.map(entity => entity.name),
+                            generatorOptions,
+                        });
+                    }
+                    else {
+                        for (const app of this.applications) {
+                            await this.composeWithJHipster(this.entitiesGenerator, {
+                                generatorArgs: app.entities.map(entity => entity.name),
+                                generatorOptions: {
+                                    ...generatorOptions,
+                                    destinationRoot: app.folder ? this.destinationPath(app.folder) : undefined,
+                                },
+                            });
+                        }
+                    }
+                }
+                else if (this.applications.length === 1) {
+                    this.log.info('Generating 1 application');
+                    await this.composeWithJHipster(this.entrypointGenerator, { generatorOptions });
+                }
+                else {
+                    this.log.info(`Generating ${this.applications.length} applications`);
+                    await this.composeWithJHipster(this.workspacesGenerator, {
+                        generatorOptions: {
+                            workspacesFolders: this.applications.map(app => app.folder),
+                            generateApplications: async () => this.runNonInteractive(this.applications, generatorOptions),
+                        },
+                    });
+                }
+            },
+        });
+    }
+    get [BaseGenerator.CONFIGURING]() {
+        return this.delegateTasksToBlueprint(() => this.configuring);
+    }
+    get end() {
+        return this.asEndTaskGroup({
+            async generateDeployments() {
+                if (!this.exportedDeployments || this.exportedDeployments.length === 0) {
+                    this.log.info('No deployment configured');
+                    return;
+                }
+                if (this.ignoreDeployments) {
+                    this.log.info(`Ignoring ${this.exportedDeployments.length} deployments`);
+                    return;
+                }
+                this.log.info(`Generating ${this.exportedDeployments.length} deployments`);
+                for (const deployment of this.exportedDeployments) {
+                    const deploymentConfig = deployment[GENERATOR_JHIPSTER];
+                    const deploymentType = deploymentConfig.deploymentType;
+                    this.log.debug(`Generating deployment: ${JSON.stringify(deploymentConfig, null, 2)}`);
+                    await this.composeWithJHipster(deploymentType, {
+                        generatorOptions: {
+                            destinationRoot: this.destinationPath(deploymentType),
+                            force: true,
+                            skipPrompts: true,
+                        },
+                    });
+                }
+            },
+        });
+    }
+    get [BaseGenerator.END]() {
+        return this.delegateTasksToBlueprint(() => this.end);
+    }
+    async runNonInteractive(applications, options) {
+        await Promise.all(applications.map(async (application) => {
+            const rootCwd = this.destinationPath();
+            const cwd = application.folder ? this.destinationPath(application.folder) : rootCwd;
+            const adapter = this.env.adapter.newAdapter();
+            const envOptions = { cwd, logCwd: rootCwd, sharedFs: application.sharedFs, adapter };
+            const generatorOptions = { ...this.options, ...options, skipPriorities: ['prompting'] };
+            // We should not reuse sharedData at non interactive runs
+            delete generatorOptions.sharedData;
+            // Install should happen at the root of the monorepository. Force skip install at childs.
+            if (this.options.monorepository) {
+                generatorOptions.skipInstall = true;
+            }
+            const envBuilder = await this.createEnvBuilder(envOptions);
+            const env = envBuilder.getEnvironment();
+            await env.run([this.entrypointGenerator], generatorOptions);
+        }));
+    }
+    writeConfig(...applications) {
+        for (const application of applications) {
+            const { folder = '', entities = [], sharedFs } = application;
+            let { config, namespaceConfigs } = application;
+            const appPath = folder ? `${folder}/` : folder;
+            const fs = sharedFs ? createMemFsEditor(sharedFs) : this.fs;
+            if (config) {
+                const configFile = this.destinationPath(`${appPath}.yo-rc.json`);
+                const oldConfig = fs.readJSON(configFile, {});
+                if (Array.isArray(config.blueprints)) {
+                    config = {
+                        ...config,
+                        blueprints: config.blueprints.map(({ name, ...remaining }) => ({ ...remaining, name: normalizeBlueprintName(name) })),
+                    };
+                }
+                if (namespaceConfigs) {
+                    namespaceConfigs = Object.fromEntries(Object.entries(namespaceConfigs).map(([ns, config]) => [normalizeBlueprintName(ns), config]));
+                }
+                fs.writeJSON(configFile, mergeYoRcContent(oldConfig, { ...namespaceConfigs, [GENERATOR_JHIPSTER]: config }));
+            }
+            for (const entity of entities) {
+                const configFile = this.destinationPath(`${appPath}${JHIPSTER_CONFIG_DIR}/${upperFirst(entity.name)}.json`);
+                const oldConfig = fs.readJSON(configFile, {});
+                fs.writeJSON(configFile, { ...oldConfig, ...entity });
+            }
+        }
+    }
+}

package/dist/generators/jdl/index.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { default } from './generator.js';
+export { default as command } from './command.js';

package/dist/generators/jdl/internal/application.js

@@ -0,0 +1,30 @@
+export const addApplicationIndex = (applicationsWithEntities) => {
+    applicationsWithEntities.forEach((applicationWithEntities, applicationIndex) => {
+        applicationWithEntities.config.applicationIndex = applicationIndex;
+    });
+};
+export const customizeForMicroservices = (applicationsWithEntities) => {
+    const gatewayApplications = Object.values(applicationsWithEntities).filter(app => app.config.applicationType === 'gateway');
+    for (const gateway of gatewayApplications) {
+        const { microfrontends = [], clientFramework: gatewayClientFramework, serverPort: gatewayServerPort } = gateway.config;
+        for (const mf of microfrontends) {
+            const { baseName, clientFramework } = applicationsWithEntities[mf.baseName].config;
+            if (clientFramework !== gatewayClientFramework) {
+                throw Error(`Using different client frameworks in microfrontends is not supported. Tried to use: ${gatewayClientFramework} with ${clientFramework} (${baseName})`);
+            }
+        }
+        const relatedBaseNames = [...microfrontends.map(mf => mf.baseName)];
+        gateway.entities
+            .map(entity => entity.microserviceName)
+            .filter(Boolean)
+            .forEach(basename => !relatedBaseNames.includes(basename) && relatedBaseNames.push(basename));
+        if (relatedBaseNames.length > 0) {
+            gateway.config.applications = Object.fromEntries(relatedBaseNames.map(baseName => {
+                const appConfig = applicationsWithEntities[baseName]?.config ?? {};
+                appConfig.gatewayServerPort = appConfig.gatewayServerPort || gatewayServerPort;
+                const { clientFramework, serverPort, applicationIndex, devServerPort } = appConfig;
+                return [baseName, { clientFramework, serverPort, applicationIndex, devServerPort }];
+            }));
+        }
+    }
+};

package/dist/generators/jdl/internal/index.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './application.js';
+export * from './utils.js';

package/dist/generators/jdl/internal/utils.js

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+/**
+ * Check if .yo-rc.json exists inside baseName folder.
+ * @param {string} baseName
+ * @return {boolean}
+ */
+export const baseNameConfigExists = baseName => existsSync(baseName === undefined ? '.yo-rc.json' : join(baseName, '.yo-rc.json'));
+/**
+ * Check if every application is new.
+ * @param {any} importState
+ * @return {boolean}
+ */
+export const allNewApplications = applications => {
+    if (applications.length < 2)
+        return !baseNameConfigExists();
+    return !applications.find(application => baseNameConfigExists(application.config.baseName));
+};

package/dist/generators/kubernetes/files.js

@@ -0,0 +1,167 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import chalk from 'chalk';
+import { applicationTypes, authenticationTypes, databaseTypes, monitoringTypes, searchEngineTypes, serviceDiscoveryTypes, ingressTypes, } from '../../jdl/jhipster/index.js';
+const { ELASTICSEARCH } = searchEngineTypes;
+const { GATEWAY, MONOLITH } = applicationTypes;
+const { JWT } = authenticationTypes;
+const { PROMETHEUS } = monitoringTypes;
+const { CONSUL, EUREKA } = serviceDiscoveryTypes;
+const { GKE } = ingressTypes;
+const NO_DATABASE = databaseTypes.NO;
+export default {
+    writeFiles,
+};
+export function writeFiles() {
+    const suffix = 'k8s';
+    return {
+        writeDeployments() {
+            for (let i = 0; i < this.appConfigs.length; i++) {
+                const appName = this.appConfigs[i].baseName.toLowerCase();
+                const appOut = appName.concat('-', suffix);
+                this.app = this.appConfigs[i];
+                this.writeFile('deployment.yml.ejs', `${appOut}/${appName}-deployment.yml`);
+                this.writeFile('service.yml.ejs', `${appOut}/${appName}-service.yml`);
+                // If we choose microservice with no DB, it is trying to move _no.yml as prodDatabaseType is getting tagged as 'string' type
+                if (this.app.databaseType !== NO_DATABASE) {
+                    const databaseType = this.app.prodDatabaseType ?? this.app.databaseType;
+                    this.writeFile(`db/${databaseType}.yml.ejs`, `${appOut}/${appName}-${databaseType}.yml`);
+                }
+                if (this.app.searchEngine === ELASTICSEARCH) {
+                    this.writeFile('db/elasticsearch.yml.ejs', `${appOut}/${appName}-elasticsearch.yml`);
+                }
+                if (this.app.applicationType === GATEWAY || this.app.applicationType === MONOLITH) {
+                    if (this.istio) {
+                        this.writeFile('istio/gateway.yml.ejs', `${appOut}/${appName}-gateway.yml`);
+                    }
+                    else if (this.kubernetesServiceType === 'Ingress') {
+                        this.writeFile('ingress.yml.ejs', `${appOut}/${appName}-ingress.yml`);
+                    }
+                }
+                if (!this.app.serviceDiscoveryAny && this.app.authenticationType === JWT) {
+                    this.writeFile('secret/jwt-secret.yml.ejs', `${appOut}/jwt-secret.yml`);
+                }
+                if (this.app.databaseTypeCouchbase) {
+                    this.writeFile('secret/couchbase-secret.yml.ejs', `${appOut}/templates/couchbase-secret.yml`);
+                }
+                if (this.monitoring === PROMETHEUS) {
+                    this.writeFile('monitoring/jhipster-prometheus-sm.yml.ejs', `${appOut}/${appName}-prometheus-sm.yml`);
+                }
+                if (this.istio) {
+                    this.writeFile('istio/destination-rule.yml.ejs', `${appOut}/${appName}-destination-rule.yml`);
+                    this.writeFile('istio/virtual-service.yml.ejs', `${appOut}/${appName}-virtual-service.yml`);
+                }
+            }
+        },
+        writeReadme() {
+            this.writeFile('README-KUBERNETES.md.ejs', 'K8S-README.md');
+        },
+        writeNamespace() {
+            if (this.kubernetesNamespace !== 'default') {
+                this.writeFile('namespace.yml.ejs', 'namespace.yml');
+            }
+        },
+        writeMessagingBroker() {
+            if (!this.useKafka)
+                return;
+            this.writeFile('messagebroker/kafka.yml.ejs', `messagebroker-${suffix}/kafka.yml`);
+        },
+        writeKeycloak() {
+            if (!this.useKeycloak)
+                return;
+            const keycloakOut = 'keycloak'.concat('-', suffix);
+            this.entryPort = '8080';
+            this.keycloakRedirectUris = '';
+            this.appConfigs.forEach(appConfig => {
+                // Add application configuration
+                if (appConfig.applicationType === GATEWAY || appConfig.applicationType === MONOLITH) {
+                    this.entryPort = appConfig.composePort;
+                    if (this.ingressDomain) {
+                        this.keycloakRedirectUris += `"http://${appConfig.baseName.toLowerCase()}.${this.kubernetesNamespace}.${this.ingressDomain}/*",
+            "https://${appConfig.baseName.toLowerCase()}.${this.kubernetesNamespace}.${this.ingressDomain}/*", `;
+                    }
+                    else {
+                        this.keycloakRedirectUris += `"http://${appConfig.baseName.toLowerCase()}:${appConfig.composePort}/*",
+            "https://${appConfig.baseName.toLowerCase()}:${appConfig.composePort}/*", `;
+                    }
+                    this.keycloakRedirectUris += `"http://localhost:${appConfig.composePort}/*",
+            "https://localhost:${appConfig.composePort}/*", `;
+                    if (appConfig.devServerPort !== undefined) {
+                        this.keycloakRedirectUris += `"http://localhost:${appConfig.devServerPort}/*", `;
+                    }
+                    this.debug(chalk.red.bold(`${appConfig.baseName} has redirect URIs ${this.keycloakRedirectUris}`));
+                    this.debug(chalk.red.bold(`AppConfig is ${JSON.stringify(appConfig)}`));
+                }
+            });
+            this.writeFile('keycloak/keycloak-configmap.yml.ejs', `${keycloakOut}/keycloak-configmap.yml`);
+            this.writeFile('keycloak/keycloak-postgresql.yml.ejs', `${keycloakOut}/keycloak-postgresql.yml`);
+            this.writeFile('keycloak/keycloak.yml.ejs', `${keycloakOut}/keycloak.yml`);
+            if (this.ingressType === GKE) {
+                this.writeFile('cert-manager/letsencrypt-staging-ca-secret.yml.ejs', 'cert-manager/letsencrypt-staging-ca-secret.yml');
+                this.writeFile('cert-manager/letsencrypt-staging-issuer.yml.ejs', 'cert-manager/letsencrypt-staging-issuer.yml');
+            }
+        },
+        writePrometheusGrafanaFiles() {
+            const monitOut = 'monitoring'.concat('-', suffix);
+            if (this.monitoring === PROMETHEUS) {
+                this.writeFile('monitoring/jhipster-prometheus-crd.yml.ejs', `${monitOut}/jhipster-prometheus-crd.yml`);
+                this.writeFile('monitoring/jhipster-prometheus-cr.yml.ejs', `${monitOut}/jhipster-prometheus-cr.yml`);
+                this.writeFile('monitoring/jhipster-grafana.yml.ejs', `${monitOut}/jhipster-grafana.yml`);
+                this.writeFile('monitoring/jhipster-grafana-dashboard.yml.ejs', `${monitOut}/jhipster-grafana-dashboard.yml`);
+                if (this.istio) {
+                    this.writeFile('istio/gateway/jhipster-grafana-gateway.yml.ejs', `${monitOut}/jhipster-grafana-gateway.yml`);
+                }
+            }
+        },
+        writeRegistryFiles() {
+            const registryOut = 'registry'.concat('-', suffix);
+            if (this.serviceDiscoveryType === EUREKA) {
+                this.writeFile('registry/jhipster-registry.yml.ejs', `${registryOut}/jhipster-registry.yml`);
+                this.writeFile('registry/application-configmap.yml.ejs', `${registryOut}/application-configmap.yml`);
+            }
+            else if (this.serviceDiscoveryType === CONSUL) {
+                this.writeFile('registry/consul.yml.ejs', `${registryOut}/consul.yml`);
+                this.writeFile('registry/consul-config-loader.yml.ejs', `${registryOut}/consul-config-loader.yml`);
+                this.writeFile('registry/application-configmap.yml.ejs', `${registryOut}/application-configmap.yml`);
+            }
+        },
+        writeConfigRunFile() {
+            this.writeFile('kubectl-apply.sh.ejs', 'kubectl-apply.sh');
+        },
+        writeObservabilityGatewayFiles() {
+            if (!this.istio)
+                return;
+            const istioOut = 'istio'.concat('-', suffix);
+            this.writeFile('istio/gateway/grafana-gateway.yml.ejs', `${istioOut}/grafana-gateway.yml`);
+            this.writeFile('istio/gateway/zipkin-gateway.yml.ejs', `${istioOut}/zipkin-gateway.yml`);
+            this.writeFile('istio/gateway/kiali-gateway.yml.ejs', `${istioOut}/kiali-gateway.yml`);
+        },
+        writeKustomize() {
+            const patchOut = 'patch'.concat('-', suffix);
+            this.writeFile('kustomize/kustomization.yml.ejs', 'kustomization.yml');
+            if (this.istio) {
+                this.writeFile('kustomize/patch/istio-label.yml.ejs', `${patchOut}/istio-label.yml`);
+                this.writeFile('kustomize/patch/istio-namespace.yml.ejs', `${patchOut}/istio-namespace.yml`);
+            }
+        },
+        writeSkaffold() {
+            this.writeFile('skaffold/skaffold.yml.ejs', 'skaffold.yml');
+        },
+    };
+}