generator-jhipster 8.0.0-beta.2 → 8.0.0-rc.1

package/dist/generators/ci-cd/command.mjs

@@ -0,0 +1,174 @@
+/**
+ * Copyright 2013-2023 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 * as _ from 'lodash-es';
+const { kebabCase, intersection } = _;
+const includesValue = (prop, values) => answers => answers[prop] && intersection(answers[prop], values);
+const command = {
+    options: {},
+    configs: {
+        ciCd: {
+            argument: {
+                type: Array,
+            },
+            prompt: {
+                type: 'checkbox',
+                message: 'What CI/CD pipeline do you want to generate?',
+            },
+            choices: [
+                { name: 'GitHub Actions', value: 'github' },
+                { name: 'Jenkins pipeline', value: 'jenkins' },
+                { name: 'GitLab CI', value: 'gitlab' },
+                { name: 'Azure Pipelines', value: 'azure' },
+                { name: 'Travis CI', value: 'travis' },
+                { name: 'CircleCI', value: 'circle' },
+            ],
+            scope: 'generator',
+        },
+        ciCdIntegrations: {
+            prompt: {
+                type: 'checkbox',
+                message: 'What tasks/integrations do you want to include ?',
+            },
+            choices: [
+                // ['jenkins', 'gitlab']
+                { name: `Deploy your application to an ${chalk.yellow('*Artifactory*')}`, value: 'deploy' },
+                // ['jenkins', 'gitlab', 'travis', 'github']
+                { name: `Analyze your code with ${chalk.yellow('*Sonar*')}`, value: 'sonar' },
+                // ['jenkins', 'github'].includes(this.pipeline)
+                { name: `Build and publish a ${chalk.yellow('*Docker*')} image`, value: 'publishDocker' },
+                // ['jenkins', 'gitlab', 'travis', 'github', 'circle', 'azure']
+                {
+                    name: `${chalk.yellow('*Snyk*')}: dependency scanning for security vulnerabilities (requires SNYK_TOKEN)`,
+                    value: 'snyk',
+                },
+                // ['jenkins', 'gitlab', 'travis', 'github', 'circle']
+                {
+                    name: `Deploy to ${chalk.yellow('*Heroku*')} (requires HEROKU_API_KEY set on CI service)`,
+                    value: 'heroku',
+                },
+                // ['github']
+                {
+                    name: `Would you like to enable the ${chalk.yellow('*Cypress Dashboard*')} (requires both CYPRESS_PROJECT_ID and CYPRESS_RECORD_KEY set on CI service)`,
+                    value: 'cypressDashboard',
+                },
+            ],
+            scope: 'generator',
+        },
+        insideDocker: {
+            prompt: {
+                when: includesValue('ciCd', ['jenkins', 'gitlab']),
+                type: 'confirm',
+                message: 'Would you like to perform the build in a Docker container ?',
+                default: false,
+            },
+            scope: 'generator',
+        },
+        sendBuildToGitlab: {
+            prompt: {
+                when: includesValue('ciCd', ['jenkins']),
+                type: 'confirm',
+                message: 'Would you like to send build status to GitLab ?',
+                default: false,
+            },
+            scope: 'generator',
+        },
+        artifactorySnapshotsId: {
+            prompt: {
+                when: includesValue('ciCdIntegrations', ['deploy']),
+                type: 'input',
+                message: `${chalk.yellow('*Artifactory*')}: what is the ID of distributionManagement for snapshots ?`,
+            },
+            default: 'snapshots',
+            scope: 'generator',
+        },
+        artifactorySnapshotsUrl: {
+            prompt: {
+                when: includesValue('ciCdIntegrations', ['deploy']),
+                type: 'input',
+                message: `${chalk.yellow('*Artifactory*')}: what is the URL of distributionManagement for snapshots ?`,
+            },
+            default: 'http://artifactory:8081/artifactory/libs-snapshot',
+            scope: 'generator',
+        },
+        artifactoryReleasesId: {
+            prompt: {
+                when: includesValue('ciCdIntegrations', ['deploy']),
+                type: 'input',
+                message: `${chalk.yellow('*Artifactory*')}: what is the ID of distributionManagement for releases ?`,
+            },
+            default: 'releases',
+            scope: 'generator',
+        },
+        artifactoryReleasesUrl: {
+            prompt: {
+                when: includesValue('ciCdIntegrations', ['deploy']),
+                type: 'input',
+                message: `${chalk.yellow('*Artifactory*')}: what is the URL of distributionManagement for releases ?`,
+            },
+            default: 'http://artifactory:8081/artifactory/libs-release',
+            scope: 'generator',
+        },
+        sonarName: {
+            prompt: {
+                when: answers => includesValue('ciCd', ['jenkins'])(answers) && includesValue('ciCdIntegrations', ['ciCdIntegrations'])(answers),
+                type: 'input',
+                message: `${chalk.yellow('*Sonar*')}: what is the name of the Sonar server ?`,
+            },
+            default: 'sonar',
+            scope: 'generator',
+        },
+        sonarUrl: {
+            prompt: {
+                when: answers => includesValue('ciCd', ['jenkins'])(answers) && includesValue('ciCdIntegrations', ['ciCdIntegrations'])(answers),
+                type: 'input',
+                message: `${chalk.yellow('*Sonar*')}: what is the URL of the Sonar server ?`,
+            },
+            default: 'https://sonarcloud.io',
+            scope: 'generator',
+        },
+        sonarOrga: {
+            prompt: {
+                when: answers => includesValue('ciCd', ['jenkins'])(answers) && includesValue('ciCdIntegrations', ['ciCdIntegrations'])(answers),
+                type: 'input',
+                message: `${chalk.yellow('*Sonar*')}: what is the Organization of the Sonar server ?`,
+            },
+            scope: 'generator',
+        },
+        dockerImage: {
+            prompt: ({ jhipsterConfigWithDefaults: config }) => ({
+                when: answers => includesValue('ciCd', ['github'])(answers) && includesValue('ciCdIntegrations', ['publishDocker'])(answers),
+                type: 'input',
+                message: `${chalk.yellow('*Docker*')}: what is the name of the image ?`,
+                default: () => `jhipster/${config.dasherizedBaseName}`,
+            }),
+            scope: 'generator',
+        },
+        herokuAppName: {
+            prompt: {
+                when: includesValue('ciCdIntegrations', ['heroku']),
+                type: 'input',
+                message: `${chalk.yellow('*Heroku*')}: name of your Heroku Application ?`,
+            },
+            scope: 'generator',
+            default: config => kebabCase(config.jhipsterConfigWithDefaults.baseName),
+        },
+    },
+};
+export default command;

package/dist/generators/ci-cd/generator.mjs

@@ -17,238 +17,164 @@
  * limitations under the License.
  */
 /* eslint-disable consistent-return */
-import _ from 'lodash';
 import chalk from 'chalk';
 import BaseApplicationGenerator from '../base-application/index.mjs';
-import prompts from './prompts.mjs';
 import statistics from '../statistics.mjs';
-import { NODE_VERSION, SERVER_MAIN_RES_DIR, JAVA_VERSION } from '../generator-constants.mjs';
 import { GENERATOR_BOOTSTRAP_APPLICATION, GENERATOR_CI_CD } from '../generator-list.mjs';
-import { buildToolTypes, clientFrameworkTypes } from '../../jdl/jhipster/index.mjs';
+import { clientFrameworkTypes } from '../../jdl/jhipster/index.mjs';
 import { createPomStorage } from '../maven/support/pom-store.mjs';
-const { MAVEN, GRADLE } = buildToolTypes;
+import command from './command.mjs';
+import { loadConfig, loadDerivedConfig } from '../../lib/internal/config-def.mjs';
 const { REACT } = clientFrameworkTypes;
-/**
- * @class
- * @extends {BaseApplicationGenerator<import('../server/types.mjs').SpringBootApplication>}
- */
 export default class CiCdGenerator extends BaseApplicationGenerator {
-    constructor(args, options, features) {
-        super(args, options, features);
-        // Automatically configure Travis
-        this.option('autoconfigure-travis', {
-            type: Boolean,
-            default: false,
-            description: 'Automatically configure Travis',
-        });
-        // Automatically configure Jenkins
-        this.option('autoconfigure-jenkins', {
-            type: Boolean,
-            default: false,
-            description: 'Automatically configure Jenkins',
-        });
-        // Automatically configure Gitlab
-        this.option('autoconfigure-gitlab', {
-            type: Boolean,
-            default: false,
-            description: 'Automatically configure Gitlab',
-        });
-        // Automatically configure Azure
-        this.option('autoconfigure-azure', {
-            type: Boolean,
-            default: false,
-            description: 'Automatically configure Azure',
-        });
-        // Automatically configure GitHub Actions
-        this.option('autoconfigure-github', {
-            type: Boolean,
-            default: false,
-            description: 'Automatically configure GitHub Actions',
-        });
-        // Automatically configure CircleCI
-        this.option('autoconfigure-circle', {
-            type: Boolean,
-            default: false,
-            description: 'Automatically configure CircleCI',
-        });
-    }
+    insideDocker;
     async beforeQueue() {
-        await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION);
         if (!this.fromBlueprint) {
             await this.composeWithBlueprints(GENERATOR_CI_CD);
         }
+        if (!this.delegateToBlueprint) {
+            await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION);
+        }
     }
     // Public API method used by the getter and also by Blueprints
     get initializing() {
-        return {
+        return this.asInitializingTaskGroup({
             sayHello() {
                 this.log.log(chalk.white('🚀 Welcome to the JHipster CI/CD Sub-Generator 🚀'));
             },
-            getSharedConfig() {
-                this.loadAppConfig();
-                this.loadServerConfig();
-                this.loadDerivedAppConfig();
-                this.loadDerivedServerConfig();
-            },
             getConfig() {
-                const configuration = this.config;
-                this.dasherizedBaseName = _.kebabCase(this.baseName);
-                this.herokuAppName = configuration.get('herokuAppName');
-                if (this.herokuAppName === undefined) {
-                    this.herokuAppName = _.kebabCase(this.baseName);
-                }
-                this.autoconfigureTravis = this.options.autoconfigureTravis;
-                this.autoconfigureJenkins = this.options.autoconfigureJenkins;
-                this.autoconfigureGitlab = this.options.autoconfigureGitlab;
-                this.autoconfigureAzure = this.options.autoconfigureAzure;
-                this.autoconfigureGithub = this.options.autoconfigureGithub;
-                this.autoconfigureCircleCI = this.options.autoconfigureCircle;
-                this.abort = false;
-            },
-            initConstants() {
-                this.NODE_VERSION = NODE_VERSION;
+                this.parseJHipsterCommand(command);
             },
-            getConstants() {
-                this.SERVER_MAIN_RES_DIR = SERVER_MAIN_RES_DIR;
-                this.JAVA_VERSION = JAVA_VERSION;
-            },
-        };
+        });
     }
     get [BaseApplicationGenerator.INITIALIZING]() {
         return this.delegateTasksToBlueprint(() => this.initializing);
     }
     // Public API method used by the getter and also by Blueprints
     get prompting() {
-        return {
-            askPipeline: prompts.askPipeline,
-            askIntegrations: prompts.askIntegrations,
-        };
+        return this.asPromptingTaskGroup({
+            async prompting() {
+                await this.prompt(this.prepareQuestions(command.configs));
+            },
+        });
     }
     get [BaseApplicationGenerator.PROMPTING]() {
         return this.delegateTasksToBlueprint(() => this.prompting);
     }
     // Public API method used by the getter and also by Blueprints
-    get configuring() {
+    get loading() {
         return {
-            insight() {
-                if (this.abort)
-                    return;
-                statistics.sendSubGenEvent('generator', GENERATOR_CI_CD);
+            loadSharedConfig({ application }) {
+                loadConfig.call(this, command.configs, { application });
             },
-            setTemplateConstants() {
-                if (this.abort)
-                    return;
-                if (this.cicdIntegrations === undefined) {
-                    this.cicdIntegrations = [];
+        };
+    }
+    get [BaseApplicationGenerator.LOADING]() {
+        return this.delegateTasksToBlueprint(() => this.loading);
+    }
+    get preparing() {
+        return this.asPreparingTaskGroup({
+            setTemplateConstants({ application }) {
+                loadDerivedConfig(command.configs, { application });
+                if (application.ciCdIntegrations === undefined) {
+                    application.ciCdIntegrations = [];
                 }
-                this.gitLabIndent = this.sendBuildToGitlab ? '    ' : '';
-                this.indent = this.insideDocker ? '    ' : '';
-                this.indent += this.gitLabIndent;
-                if (this.clientFramework === REACT) {
-                    this.frontTestCommand = 'test-ci';
+                application.gitLabIndent = application.sendBuildToGitlab ? '    ' : '';
+                application.indent = application.insideDocker ? '    ' : '';
+                application.indent += application.gitLabIndent;
+                if (application.clientFramework === REACT) {
+                    application.frontTestCommand = 'test-ci';
                 }
                 else {
-                    this.frontTestCommand = 'test';
+                    application.frontTestCommand = 'test';
                 }
             },
-        };
-    }
-    get [BaseApplicationGenerator.CONFIGURING]() {
-        return this.delegateTasksToBlueprint(() => this.configuring);
-    }
-    _loadCiCdConfig(config = this.jhipsterConfigWithDefaults, dest = this) {
-        dest.cicdIntegrations = dest.cicdIntegrations || config.cicdIntegrations || [];
-        dest.cicdIntegrationsSnyk = dest.cicdIntegrations.includes('snyk');
-        dest.cicdIntegrationsSonar = dest.cicdIntegrations.includes('sonar');
-        dest.cicdIntegrationsHeroku = dest.cicdIntegrations.includes('heroku');
-        dest.cicdIntegrationsDeploy = dest.cicdIntegrations.includes('deploy');
-        dest.cicdIntegrationsPublishDocker = dest.cicdIntegrations.includes('publishDocker');
-        dest.cicdIntegrationsCypressDashboard = dest.cicdIntegrations.includes('cypressDashboard');
-    }
-    // Public API method used by the getter and also by Blueprints
-    get loading() {
-        return {
-            loadSharedConfig() {
-                this._loadCiCdConfig();
-            },
-        };
+        });
     }
-    get [BaseApplicationGenerator.LOADING]() {
-        return this.delegateTasksToBlueprint(() => this.loading);
+    get [BaseApplicationGenerator.PREPARING]() {
+        return this.delegateTasksToBlueprint(() => this.preparing);
     }
     // Public API method used by the getter and also by Blueprints
     get writing() {
         return this.asWritingTaskGroup({
+            insight() {
+                statistics.sendSubGenEvent('generator', GENERATOR_CI_CD);
+            },
             async writeFiles({ application }) {
-                Object.assign(this, application);
-                if (this.pipeline === 'jenkins') {
-                    await this.writeFiles({
-                        rootTemplatesPath: 'jenkins',
-                        blocks: [
-                            {
-                                templates: [
-                                    {
-                                        sourceFile: 'Jenkinsfile',
-                                        destinationFile: 'Jenkinsfile',
-                                    },
-                                    {
-                                        sourceFile: 'jenkins.yml',
-                                        destinationFile: `${application.dockerServicesDir}jenkins.yml`,
-                                    },
-                                    {
-                                        sourceFile: 'idea.gdsl',
-                                        destinationFile: `${application.srcMainResources}idea.gdsl`,
-                                    },
-                                ],
-                            },
-                        ],
-                        context: this,
-                    });
-                }
-                if (this.pipeline === 'gitlab') {
-                    this.writeFile('.gitlab-ci.yml.ejs', '.gitlab-ci.yml');
-                }
-                if (this.pipeline === 'circle') {
-                    this.writeFile('circle.yml.ejs', '.circleci/config.yml');
-                }
-                if (this.pipeline === 'travis') {
-                    this.writeFile('travis.yml.ejs', '.travis.yml');
-                }
-                if (this.pipeline === 'azure') {
-                    this.writeFile('azure-pipelines.yml.ejs', 'azure-pipelines.yml');
-                }
-                if (this.pipeline === 'github') {
-                    this.writeFile('github-actions.yml.ejs', '.github/workflows/main.yml');
+                await this.writeFiles({
+                    blocks: [
+                        {
+                            condition: ctx => ctx.ciCdJenkins,
+                            templates: [
+                                {
+                                    sourceFile: 'jenkins/Jenkinsfile',
+                                    destinationFile: 'Jenkinsfile',
+                                },
+                                {
+                                    sourceFile: 'jenkins/jenkins.yml',
+                                    destinationFile: `${application.dockerServicesDir}jenkins.yml`,
+                                },
+                                {
+                                    sourceFile: 'jenkins/idea.gdsl',
+                                    destinationFile: `${application.srcMainResources}idea.gdsl`,
+                                },
+                            ],
+                        },
+                        {
+                            condition: ctx => ctx.ciCdGitlab,
+                            templates: ['.gitlab-ci.yml'],
+                        },
+                        {
+                            condition: ctx => ctx.ciCdCircle,
+                            templates: ['.circleci/config.yml'],
+                        },
+                        {
+                            condition: ctx => ctx.ciCdTravis,
+                            templates: ['.travis.yml'],
+                        },
+                        {
+                            condition: ctx => ctx.ciCdAzure,
+                            templates: ['azure-pipelines.yml'],
+                        },
+                        {
+                            condition: ctx => ctx.ciCdGithub,
+                            templates: ['.github/workflows/main.yml'],
+                        },
+                    ],
+                    context: application,
+                });
+                if (application.ciCdIntegrations.includes('publishDocker')) {
+                    this.writeFile('docker-registry.yml.ejs', `${application.dockerServicesDir}docker-registry.yml`);
                 }
-                if (this.cicdIntegrations.includes('deploy')) {
-                    if (this.buildTool === MAVEN) {
-                        this.addMavenDistributionManagement(this.artifactorySnapshotsId, this.artifactorySnapshotsUrl, this.artifactoryReleasesId, this.artifactoryReleasesUrl);
+            },
+        });
+    }
+    get [BaseApplicationGenerator.WRITING]() {
+        return this.delegateTasksToBlueprint(() => this.writing);
+    }
+    // Public API method used by the getter and also by Blueprints
+    get postWriting() {
+        return this.asPostWritingTaskGroup({
+            postWriting({ application }) {
+                if (application.ciCdIntegrations.includes('deploy')) {
+                    if (application.buildToolMaven) {
+                        createPomStorage(this).addDistributionManagement({
+                            releasesId: application.artifactoryReleasesId,
+                            releasesUrl: application.artifactoryReleasesUrl,
+                            snapshotsId: application.artifactorySnapshotsId,
+                            snapshotsUrl: application.artifactorySnapshotsUrl,
+                        });
                     }
-                    else if (this.buildTool === GRADLE) {
+                    else if (application.buildToolGradle) {
                         // TODO: add support here
                         // this.addGradleDistributionManagement(this.artifactoryId, this.artifactoryName);
                         this.log.warn('No support for Artifactory yet, when using Gradle.\n');
                     }
                 }
-                if (this.cicdIntegrations.includes('publishDocker')) {
-                    this.writeFile('docker-registry.yml.ejs', `${application.dockerServicesDir}docker-registry.yml`);
-                }
             },
         });
     }
-    get [BaseApplicationGenerator.WRITING]() {
-        return this.delegateTasksToBlueprint(() => this.writing);
-    }
-    /**
-     * @private
-     * Add a distributionManagement to the Maven build.
-     *
-     * @param {string} snapshotsId Snapshots Repository Id
-     * @param {string} snapshotsUrl Snapshots Repository Url
-     * @param {string} releasesId Repository Id
-     * @param {string} releasesUrl Repository Url
-     */
-    addMavenDistributionManagement(snapshotsId, snapshotsUrl, releasesId, releasesUrl) {
-        createPomStorage(this).addDistributionManagement({ snapshotsId, snapshotsUrl, releasesId, releasesUrl });
+    get [BaseApplicationGenerator.POST_WRITING]() {
+        return this.delegateTasksToBlueprint(() => this.postWriting);
     }
 }

package/dist/generators/ci-cd/templates/.circleci/config.yml.ejs

@@ -0,0 +1,123 @@
+<%#
+ Copyright 2013-2023 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.
+-%>
+version: 2.1
+jobs:
+    build:
+        machine:
+            image: ubuntu-2004:current
+        resource_class: large
+        steps:
+            - checkout
+            # Download and cache dependencies
+            - restore_cache:
+                keys:
+                    <%_ if (buildToolMaven) { _%>
+                    - v1-dependencies-{{ checksum "pom.xml" }}-{{ checksum "package-lock.json" }}
+                    <%_ } else if (buildToolGradle) { _%>
+                    - v1-dependencies-{{ checksum "build.gradle" }}-{{ checksum "package-lock.json" }}
+                    <%_ } _%>
+                    # Perform a Partial Cache Restore (https://circleci.com/docs/2.0/caching/#restoring-cache)
+                    - v1-dependencies-
+            - run:
+                name: Print Java Version
+                command: 'java -version'
+            - run:
+                name: Print Node Version
+                command: 'node -v'
+            - run:
+                name: Print NPM Version
+                command: 'npm -v'
+            - run:
+                name: Install Node Modules
+                command: 'npm install'
+            <%_ if (ciCdIntegrationsSnyk) { _%>
+            - run:
+                name: Install Snyk CLI
+                command: |
+                    curl -Lo ./snyk $(curl -s https://api.github.com/repos/snyk/snyk/releases/latest | grep "browser_download_url.*snyk-linux" | cut -d ':' -f 2,3 | tr -d \" | tr -d ' ')
+                    chmod +x snyk
+            - run:
+                name: Snyk test
+                command: './snyk test --all-projects || true'
+            - run:
+                name: Snyk monitor
+                command: './snyk monitor --all-projects'
+            <%_ } _%>
+            - save_cache:
+                paths:
+                    - node
+                    - node_modules
+                    <%_ if (buildToolMaven) { _%>
+                    - ~/.m2
+                    <%_ } else if (buildToolGradle) { _%>
+                    - ~/.gradle
+                    <%_ } _%>
+                    <%_ if (buildToolMaven) { _%>
+                key: v1-dependencies-{{ checksum "pom.xml" }}-{{ checksum "package-lock.json" }}
+                    <%_ } else if (buildToolGradle) { _%>
+                key: v1-dependencies-{{ checksum "build.gradle" }}-{{ checksum "package-lock.json" }}
+                    <%_ } _%>
+
+            - run:
+                name: Give Executable Power
+            <%_ if (buildToolMaven) { _%>
+                command: 'chmod +x mvnw'
+            <%_ } else if (buildToolGradle) { _%>
+                command: 'chmod +x gradlew'
+            <%_ } _%>
+            - run:
+                name: Backend tests
+                command: <%= clientPackageManager %> run ci:backend:test
+            <%_ if (!skipClient) { _%>
+            - run:
+                name: Run Front End Tests
+                command: <%= clientPackageManager %> run ci:frontend:test
+            <%_ } _%>
+            <%_ if (buildToolMaven) { _%>
+                <%_ if (ciCdIntegrationsHeroku) { _%>
+            - run:
+                name: Deploy to Heroku
+                command: './mvnw -ntp com.heroku.sdk:heroku-maven-plugin:2.0.5:deploy -DskipTests -Pprod -Dheroku.buildpacks=heroku/jvm -Dheroku.appName=<%= herokuAppName %>'
+                <%_ } _%>
+            <%_ } else if (buildToolGradle) { _%>
+                <%_ if (ciCdIntegrationsHeroku) { _%>
+            - run:
+                name: Deploy to Heroku
+                command: './gradlew deployHeroku --no-daemon'
+                <%_ } _%>
+            <%_ } _%>
+            <%_ if (cypressTests) {
+                const commented = '# '; _%>
+            <%= commented %>- run:
+            <%= commented %>    name: 'E2E: Package'
+            <%= commented %>    command: <%= clientPackageManager %> run ci:e2e:package
+            <%= commented %>- run:
+            <%= commented %>    name: 'E2E: Prepare'
+            <%= commented %>    command: <%= clientPackageManager %> run ci:e2e:prepare
+            <%= commented %>- run:
+            <%= commented %>    name: 'E2E: Run'
+            <%= commented %>    command: <%= clientPackageManager %> run ci:e2e:run
+            <%_ if(cypressTests) { _%>
+            <%= commented %>    environment:
+            <%= commented %>      CYPRESS_ENABLE_RECORD: <%= ciCdIntegrationsCypressDashboard %>
+            <%_ } _%>
+            <%= commented %>- run:
+            <%= commented %>    name: 'E2E: Teardown'
+            <%= commented %>    command: <%= clientPackageManager %> run ci:e2e:teardown
+            <%_ } _%>