nx 21.0.0-beta.11 → 21.0.0-beta.12

package/src/command-line/release/utils/remote-release-clients/gitlab.d.ts

@@ -0,0 +1,62 @@
+import type { PostGitTask } from '../../changelog';
+import type { ResolvedCreateRemoteReleaseProvider } from '../../config/config';
+import type { Reference } from '../git';
+import { ReleaseVersion } from '../shared';
+import { RemoteReleaseClient, RemoteReleaseOptions, RemoteReleaseResult, RemoteRepoData } from './remote-release-client';
+export interface GitLabRepoData extends RemoteRepoData {
+    projectId: string;
+}
+export interface GitLabRelease {
+    id?: string;
+    name?: string;
+    tag_name: string;
+    ref: string;
+    assets?: {
+        links?: {
+            name: string;
+            url: string;
+            direct_asset_path?: string;
+            link_type?: string;
+        }[];
+    };
+    released_at?: string;
+    description?: string;
+    milestones?: string[];
+    prerelease?: boolean;
+}
+export declare const defaultCreateReleaseProvider: ResolvedCreateRemoteReleaseProvider;
+export declare class GitLabRemoteReleaseClient extends RemoteReleaseClient<GitLabRelease> {
+    remoteReleaseProviderName: string;
+    /**
+     * Get GitLab repository data from git remote
+     */
+    static resolveRepoData(createReleaseConfig: false | ResolvedCreateRemoteReleaseProvider, remoteName?: string): GitLabRepoData | null;
+    /**
+     * Resolve a GitLab token from various environment variables
+     */
+    static resolveTokenData(hostname: string): Promise<{
+        token: string;
+        headerName: string;
+    } | null>;
+    createPostGitTask(releaseVersion: ReleaseVersion, changelogContents: string, dryRun: boolean): PostGitTask;
+    applyUsernameToAuthors(): Promise<void>;
+    protected getReleaseByTag(tag: string): Promise<GitLabRelease>;
+    protected createRelease(remoteRelease: GitLabRelease): Promise<any>;
+    protected updateRelease(_id: string, remoteRelease: GitLabRelease): Promise<any>;
+    /**
+     * Generate a URL for manual release creation on GitLab. Sadly, unlike GitHub, GitLab does not
+     * seem to respect query string parameters for setting the UI form fields, so the user has to
+     * start from scratch.
+     */
+    protected getManualRemoteReleaseURL(_remoteReleaseOptions: RemoteReleaseOptions): string;
+    protected handleAuthError(): void;
+    protected logReleaseAction(existingRelease: GitLabRelease | undefined, gitTag: string, dryRun: boolean): void;
+    protected handleError(error: any, result: RemoteReleaseResult): Promise<void>;
+    private promptForContinueInGitLab;
+    /**
+     * Format references for the release (e.g., MRs, issues)
+     */
+    formatReferences(references: Reference[]): string;
+    protected syncRelease(remoteReleaseOptions: RemoteReleaseOptions, existingRelease?: GitLabRelease): Promise<RemoteReleaseResult>;
+    private getRequiredRemoteRepoData;
+}

package/src/command-line/release/utils/remote-release-clients/gitlab.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLabRemoteReleaseClient = exports.defaultCreateReleaseProvider = void 0;
+const chalk = require("chalk");
+const enquirer_1 = require("enquirer");
+const node_child_process_1 = require("node:child_process");
+const output_1 = require("../../../../utils/output");
+const remote_release_client_1 = require("./remote-release-client");
+exports.defaultCreateReleaseProvider = {
+    provider: 'gitlab',
+    hostname: 'gitlab.com',
+    apiBaseUrl: 'https://gitlab.com/api/v4',
+};
+class GitLabRemoteReleaseClient extends remote_release_client_1.RemoteReleaseClient {
+    constructor() {
+        super(...arguments);
+        this.remoteReleaseProviderName = 'GitLab';
+    }
+    /**
+     * Get GitLab repository data from git remote
+     */
+    static resolveRepoData(createReleaseConfig, remoteName = 'origin') {
+        try {
+            const remoteUrl = (0, node_child_process_1.execSync)(`git remote get-url ${remoteName}`, {
+                encoding: 'utf8',
+                stdio: 'pipe',
+            }).trim();
+            // Use the default provider if custom one is not specified or releases are disabled
+            let hostname = exports.defaultCreateReleaseProvider.hostname;
+            let apiBaseUrl = exports.defaultCreateReleaseProvider.apiBaseUrl;
+            if (createReleaseConfig !== false &&
+                typeof createReleaseConfig !== 'string') {
+                hostname = createReleaseConfig.hostname || hostname;
+                apiBaseUrl = createReleaseConfig.apiBaseUrl || apiBaseUrl;
+            }
+            // Extract the project path from the URL
+            const escapedHostname = hostname.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const regexString = `${escapedHostname}[/:]([\\w.-]+/[\\w.-]+(?:/[\\w.-]+)*)(\\.git)?`;
+            const regex = new RegExp(regexString);
+            const match = remoteUrl.match(regex);
+            if (match && match[1]) {
+                // Remove trailing .git if present
+                const slug = match[1].replace(/\.git$/, '');
+                // Encode the project path for use in API URLs
+                const projectId = encodeURIComponent(slug);
+                return {
+                    hostname,
+                    apiBaseUrl,
+                    slug,
+                    projectId,
+                };
+            }
+            else {
+                throw new Error(`Could not extract project path data from the resolved remote URL: ${remoteUrl}`);
+            }
+        }
+        catch (err) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(err);
+            }
+            return null;
+        }
+    }
+    /**
+     * Resolve a GitLab token from various environment variables
+     */
+    static async resolveTokenData(hostname) {
+        // Try and resolve from the environment
+        const tokenFromEnv = process.env.GITLAB_TOKEN || process.env.GL_TOKEN;
+        if (tokenFromEnv) {
+            return { token: tokenFromEnv, headerName: 'PRIVATE-TOKEN' };
+        }
+        // Try and resolve from a CI environment
+        if (process.env.CI_JOB_TOKEN) {
+            return { token: process.env.CI_JOB_TOKEN, headerName: 'JOB-TOKEN' };
+        }
+        if (hostname !== 'gitlab.com') {
+            console.log(`Warning: It was not possible to automatically resolve a GitLab token from your environment for hostname ${hostname}. If you set the GITLAB_TOKEN or GL_TOKEN environment variable (or you are in GitLab CI where CI_JOB_TOKEN is set automatically), that will be used for GitLab API requests.`);
+        }
+        return null;
+    }
+    createPostGitTask(releaseVersion, changelogContents, dryRun) {
+        return async (latestCommit) => {
+            output_1.output.logSingleLine(`Creating GitLab Release`);
+            await this.createOrUpdateRelease(releaseVersion, changelogContents, latestCommit, { dryRun });
+        };
+    }
+    // Not implemented for GitLab yet, the changelog renderer should not call this method
+    async applyUsernameToAuthors() {
+        throw new Error('applyUsernameToAuthors is not implemented for GitLab yet');
+    }
+    async getReleaseByTag(tag) {
+        const gitlabRepoData = this.getRequiredRemoteRepoData();
+        return await this.makeRequest(`/projects/${gitlabRepoData.projectId}/releases/${encodeURIComponent(tag)}`);
+    }
+    async createRelease(remoteRelease) {
+        const gitlabRepoData = this.getRequiredRemoteRepoData();
+        return await this.makeRequest(`/projects/${gitlabRepoData.projectId}/releases`, {
+            method: 'POST',
+            data: remoteRelease,
+        });
+    }
+    async updateRelease(_id, remoteRelease) {
+        const gitlabRepoData = this.getRequiredRemoteRepoData();
+        return await this.makeRequest(`/projects/${gitlabRepoData.projectId}/releases/${encodeURIComponent(remoteRelease.tag_name)}`, {
+            method: 'PUT',
+            data: remoteRelease,
+        });
+    }
+    /**
+     * Generate a URL for manual release creation on GitLab. Sadly, unlike GitHub, GitLab does not
+     * seem to respect query string parameters for setting the UI form fields, so the user has to
+     * start from scratch.
+     */
+    getManualRemoteReleaseURL(_remoteReleaseOptions) {
+        const gitlabRepoData = this.getRequiredRemoteRepoData();
+        return `https://${gitlabRepoData.hostname}/${gitlabRepoData.slug}/-/releases/new`;
+    }
+    handleAuthError() {
+        output_1.output.error({
+            title: `Unable to resolve data via the GitLab API.`,
+            bodyLines: [
+                '- Set the `GITLAB_TOKEN` or `GL_TOKEN` environment variable to a valid GitLab token with `api` scope',
+                '- If running in GitLab CI, the automatically provisioned CI_JOB_TOKEN can also be used',
+            ],
+        });
+    }
+    logReleaseAction(existingRelease, gitTag, dryRun) {
+        const gitlabRepoData = this.getRequiredRemoteRepoData();
+        const logTitle = `https://${gitlabRepoData.hostname}/${gitlabRepoData.slug}/-/releases/${encodeURIComponent(gitTag)}`;
+        if (existingRelease) {
+            console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+        }
+        else {
+            console.error(`${chalk.green('CREATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+        }
+    }
+    async handleError(error, result) {
+        if (error) {
+            process.exitCode = 1;
+            if (error.response?.data) {
+                output_1.output.error({
+                    title: `A GitLab API Error occurred when creating/updating the release`,
+                    bodyLines: [
+                        `GitLab Error: ${JSON.stringify(error.response.data)}`,
+                        `---`,
+                        `Request Data:`,
+                        `Repo: ${this.getRemoteRepoData()?.slug}`,
+                        `Token Header Data: ${this.tokenHeader}`,
+                        `Body: ${JSON.stringify(result.requestData)}`,
+                    ],
+                });
+            }
+            else {
+                console.log(error);
+                console.error(`An unknown error occurred while trying to create a release on GitLab, please report this on https://github.com/nrwl/nx (NOTE: make sure to redact your GitLab token from the error message!)`);
+            }
+        }
+        const shouldContinueInGitLab = await this.promptForContinueInGitLab();
+        if (!shouldContinueInGitLab) {
+            return;
+        }
+        const open = require('open');
+        await open(result.url)
+            .then(() => {
+            console.info(`\nFollow up in the browser to manually create the release:\n\n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                `\n`);
+        })
+            .catch(() => {
+            console.info(`Open this link to manually create a release: \n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                '\n');
+        });
+    }
+    async promptForContinueInGitLab() {
+        try {
+            const reply = await (0, enquirer_1.prompt)([
+                {
+                    name: 'open',
+                    message: 'Do you want to create the release manually in your browser?',
+                    type: 'autocomplete',
+                    choices: [
+                        {
+                            name: 'Yes',
+                            hint: 'It will open the GitLab release page for you',
+                        },
+                        {
+                            name: 'No',
+                        },
+                    ],
+                    initial: 0,
+                },
+            ]);
+            return reply.open === 'Yes';
+        }
+        catch {
+            // Ensure the cursor is always restored before exiting
+            process.stdout.write('\u001b[?25h');
+            // Handle the case where the user exits the prompt with ctrl+c
+            process.exit(1);
+        }
+    }
+    /**
+     * Format references for the release (e.g., MRs, issues)
+     */
+    formatReferences(references) {
+        const gitlabRepoData = this.getRequiredRemoteRepoData();
+        const providerToRefSpec = {
+            gitlab: {
+                'pull-request': 'merge_requests',
+                hash: 'commit',
+                issue: 'issues',
+            },
+        };
+        const refSpec = providerToRefSpec.gitlab;
+        const formatSingleReference = (ref) => {
+            return `https://${gitlabRepoData.hostname}/${gitlabRepoData.slug}/-/${refSpec[ref.type]}/${ref.value.replace(/^[#!]/, '')}`;
+        };
+        const mr = references.filter((ref) => ref.type === 'pull-request');
+        const issue = references.filter((ref) => ref.type === 'issue');
+        if (mr.length > 0 || issue.length > 0) {
+            return (' (' +
+                [...mr, ...issue].map((ref) => formatSingleReference(ref)).join(', ') +
+                ')');
+        }
+        if (references.length > 0) {
+            return ' (' + formatSingleReference(references[0]) + ')';
+        }
+        return '';
+    }
+    async syncRelease(remoteReleaseOptions, existingRelease) {
+        const gitlabReleaseData = {
+            tag_name: remoteReleaseOptions.version,
+            name: remoteReleaseOptions.version,
+            description: remoteReleaseOptions.body,
+            prerelease: remoteReleaseOptions.prerelease,
+            ref: remoteReleaseOptions.commit,
+            released_at: new Date().toISOString(),
+            assets: { links: [] },
+            milestones: [],
+        };
+        try {
+            const newGlRelease = await (existingRelease
+                ? this.updateRelease(existingRelease.id, gitlabReleaseData)
+                : this.createRelease(gitlabReleaseData));
+            const gitlabRepoData = this.getRequiredRemoteRepoData();
+            return {
+                status: existingRelease ? 'updated' : 'created',
+                id: newGlRelease.tag_name,
+                url: `https://${gitlabRepoData.hostname}/${gitlabRepoData.slug}/-/tags/${encodeURIComponent(remoteReleaseOptions.version)}`,
+            };
+        }
+        catch (error) {
+            return {
+                status: 'manual',
+                error,
+                url: this.getManualRemoteReleaseURL(remoteReleaseOptions),
+                requestData: gitlabReleaseData,
+            };
+        }
+    }
+    getRequiredRemoteRepoData() {
+        const gitlabRepoData = this.getRemoteRepoData();
+        if (!gitlabRepoData) {
+            throw new Error(`No remote repo data could be resolved for the current workspace`);
+        }
+        return gitlabRepoData;
+    }
+}
+exports.GitLabRemoteReleaseClient = GitLabRemoteReleaseClient;

package/src/command-line/release/utils/remote-release-clients/remote-release-client.d.ts

@@ -0,0 +1,111 @@
+import type { AxiosRequestConfig } from 'axios';
+import type { PostGitTask } from '../../changelog';
+import { ResolvedCreateRemoteReleaseProvider } from '../../config/config';
+import type { Reference } from '../git';
+import { type ReleaseVersion } from '../shared';
+import type { GithubRemoteReleaseClient } from './github';
+import type { GitLabRemoteReleaseClient } from './gitlab';
+export type RemoteRepoSlug = `${string}/${string}`;
+export interface RemoteRepoData {
+    hostname: string;
+    slug: RemoteRepoSlug;
+    apiBaseUrl: string;
+}
+export interface RemoteReleaseOptions {
+    version: string;
+    body: string;
+    prerelease: boolean;
+    commit: string;
+}
+export interface RemoteReleaseResult {
+    status: 'created' | 'updated' | 'manual';
+    id?: string;
+    url?: string;
+    error?: any;
+    requestData?: any;
+}
+/**
+ * Abstract base class for remote release clients
+ */
+export declare abstract class RemoteReleaseClient<RemoteRelease extends Record<string, any>> {
+    private remoteRepoData;
+    protected createReleaseConfig: false | ResolvedCreateRemoteReleaseProvider;
+    protected tokenData: {
+        token: string;
+        headerName: string;
+    } | null;
+    /**
+     * Used in user-facing messaging
+     */
+    abstract remoteReleaseProviderName: string;
+    protected tokenHeader: Record<string, string>;
+    constructor(remoteRepoData: RemoteRepoData | null, createReleaseConfig: false | ResolvedCreateRemoteReleaseProvider, tokenData: {
+        token: string;
+        headerName: string;
+    } | null);
+    getRemoteRepoData<T extends RemoteRepoData>(): T | null;
+    /**
+     * Create a post git task that will be executed by nx release changelog after performing any relevant
+     * git operations, if the user has opted into remote release creation.
+     */
+    abstract createPostGitTask(releaseVersion: ReleaseVersion, changelogContents: string, dryRun: boolean): PostGitTask;
+    /**
+     * Apply authors' corresponding usernames, if applicable, on the remote release provider. It is designed to be
+     * invoked by a changelog renderer implementation.
+     */
+    abstract applyUsernameToAuthors(authors: Map<string, {
+        email: Set<string>;
+        username?: string;
+    }>): Promise<void>;
+    /**
+     * Make an (optionally authenticated) API request to the remote release provider
+     */
+    protected makeRequest(url: string, opts?: AxiosRequestConfig): Promise<any>;
+    createOrUpdateRelease(releaseVersion: ReleaseVersion, changelogContents: string, latestCommit: string, { dryRun }: {
+        dryRun: boolean;
+    }): Promise<void>;
+    /**
+     * Format references for the release (e.g., PRs, issues)
+     */
+    formatReferences(_references: Reference[]): string;
+    /**
+     * Handle non-auth related errors when creating releases
+     */
+    protected abstract handleError(error: any, result: RemoteReleaseResult): Promise<void>;
+    /**
+     * Display authentication error message
+     */
+    protected abstract handleAuthError(): void;
+    /**
+     * Log the release action (create or update)
+     */
+    protected abstract logReleaseAction(existingRelease: RemoteRelease | undefined, gitTag: string, dryRun: boolean): void;
+    /**
+     * Print changelog changes
+     */
+    protected printRemoteReleaseContents(existingBody: string, newBody: string): void;
+    /**
+     * Get a release by tag
+     */
+    protected abstract getReleaseByTag(tag: string): Promise<RemoteRelease>;
+    /**
+     * Create a manual release URL used to create/edit a release in the remote release provider's UI
+     */
+    protected abstract getManualRemoteReleaseURL(remoteReleaseOptions: RemoteReleaseOptions): string;
+    /**
+     * Create a new release
+     */
+    protected abstract createRelease(body: RemoteRelease): Promise<any>;
+    /**
+     * Update an existing release
+     */
+    protected abstract updateRelease(id: string, body: RemoteRelease): Promise<any>;
+    /**
+     * Synchronize a release with the remote release provider
+     */
+    protected abstract syncRelease(remoteReleaseOptions: RemoteReleaseOptions, existingRelease?: RemoteRelease): Promise<RemoteReleaseResult>;
+}
+/**
+ * Factory function to create a remote release client based on the given configuration
+ */
+export declare function createRemoteReleaseClient(createReleaseConfig: false | ResolvedCreateRemoteReleaseProvider, remoteName?: string): Promise<GithubRemoteReleaseClient | GitLabRemoteReleaseClient | null>;

package/src/command-line/release/utils/remote-release-clients/remote-release-client.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteReleaseClient = void 0;
+exports.createRemoteReleaseClient = createRemoteReleaseClient;
+const axios_1 = require("axios");
+const print_changes_1 = require("../print-changes");
+const shared_1 = require("../shared");
+/**
+ * Abstract base class for remote release clients
+ */
+class RemoteReleaseClient {
+    constructor(
+    // A workspace isn't guaranteed to have a remote
+    remoteRepoData, createReleaseConfig, tokenData) {
+        this.remoteRepoData = remoteRepoData;
+        this.createReleaseConfig = createReleaseConfig;
+        this.tokenData = tokenData;
+        this.tokenHeader = {};
+        if (tokenData) {
+            if (tokenData.headerName === 'Authorization') {
+                this.tokenHeader[tokenData.headerName] = `Bearer ${tokenData.token}`;
+            }
+            else {
+                this.tokenHeader[tokenData.headerName] = tokenData.token;
+            }
+        }
+    }
+    getRemoteRepoData() {
+        return this.remoteRepoData;
+    }
+    /**
+     * Make an (optionally authenticated) API request to the remote release provider
+     */
+    async makeRequest(url, opts = {}) {
+        const remoteRepoData = this.getRemoteRepoData();
+        if (!remoteRepoData) {
+            throw new Error(`No remote repo data could be resolved for the current workspace`);
+        }
+        const config = {
+            ...opts,
+            baseURL: remoteRepoData.apiBaseUrl,
+            headers: {
+                ...opts.headers,
+                ...this.tokenHeader,
+            },
+        };
+        return (await (0, axios_1.default)(url, config)).data;
+    }
+    async createOrUpdateRelease(releaseVersion, changelogContents, latestCommit, { dryRun }) {
+        let existingRelease;
+        try {
+            existingRelease = await this.getReleaseByTag(releaseVersion.gitTag);
+        }
+        catch (err) {
+            if (err.response?.status === 401) {
+                this.handleAuthError();
+                process.exit(1);
+            }
+            if (err.response?.status === 404) {
+                // No existing release found, this is fine
+            }
+            else {
+                // Rethrow unknown errors for now
+                throw err;
+            }
+        }
+        this.logReleaseAction(existingRelease, releaseVersion.gitTag, dryRun);
+        this.printRemoteReleaseContents(existingRelease
+            ? 'body' in existingRelease
+                ? existingRelease.body
+                : 'description' in existingRelease
+                    ? existingRelease.description
+                    : ''
+            : '', changelogContents);
+        if (!dryRun) {
+            const remoteReleaseOptions = {
+                version: releaseVersion.gitTag,
+                prerelease: releaseVersion.isPrerelease,
+                body: changelogContents,
+                commit: latestCommit,
+            };
+            const result = await this.syncRelease(remoteReleaseOptions, existingRelease);
+            if (result.status === 'manual') {
+                await this.handleError(result.error, result);
+            }
+        }
+    }
+    /**
+     * Format references for the release (e.g., PRs, issues)
+     */
+    formatReferences(_references) {
+        // Base implementation - to be overridden by specific providers
+        return '';
+    }
+    /**
+     * Print changelog changes
+     */
+    printRemoteReleaseContents(existingBody, newBody) {
+        console.log('');
+        (0, print_changes_1.printDiff)(existingBody, newBody, 3, shared_1.noDiffInChangelogMessage);
+    }
+}
+exports.RemoteReleaseClient = RemoteReleaseClient;
+/**
+ * Factory function to create a remote release client based on the given configuration
+ */
+async function createRemoteReleaseClient(createReleaseConfig, remoteName = 'origin') {
+    switch (true) {
+        // GitHub and GitHub Enterprise Server
+        case typeof createReleaseConfig === 'object' &&
+            (createReleaseConfig.provider === 'github-enterprise-server' ||
+                createReleaseConfig.provider === 'github'):
+        // If remote releases are disabled, assume GitHub repo data resolution (but don't attempt to resolve a token) to match existing behavior
+        case createReleaseConfig === false: {
+            const { GithubRemoteReleaseClient } = await Promise.resolve().then(() => require('./github'));
+            const repoData = GithubRemoteReleaseClient.resolveRepoData(createReleaseConfig, remoteName);
+            const token = createReleaseConfig && repoData
+                ? await GithubRemoteReleaseClient.resolveTokenData(repoData.hostname)
+                : null;
+            return new GithubRemoteReleaseClient(repoData, createReleaseConfig, token);
+        }
+        // GitLab
+        case typeof createReleaseConfig === 'object' &&
+            createReleaseConfig.provider === 'gitlab':
+            {
+                const { GitLabRemoteReleaseClient } = await Promise.resolve().then(() => require('./gitlab'));
+                const repoData = GitLabRemoteReleaseClient.resolveRepoData(createReleaseConfig, remoteName);
+                const tokenData = repoData
+                    ? await GitLabRemoteReleaseClient.resolveTokenData(repoData.hostname)
+                    : null;
+                return new GitLabRemoteReleaseClient(repoData, createReleaseConfig, tokenData);
+            }
+        default:
+            throw new Error(`Unsupported remote release configuration: ${JSON.stringify(createReleaseConfig)}`);
+    }
+}

package/src/command-line/yargs-utils/shared-options.d.ts

@@ -64,7 +64,7 @@ export declare function withOverrides<T extends {
 }>(args: T, commandLevel?: number): T & {
     __overrides_unparsed__: string[];
 };
-declare const allOutputStyles: readonly ["dynamic", "static", "stream", "stream-without-prefixes", "compact"];
+declare const allOutputStyles: readonly ["tui", "dynamic", "dynamic-legacy", "static", "stream", "stream-without-prefixes", "compact"];
 export type OutputStyle = (typeof allOutputStyles)[number];
 export declare function withOutputStyleOption(yargs: Argv, choices?: ReadonlyArray<OutputStyle>): Argv<{
     "output-style": string;

package/src/command-line/yargs-utils/shared-options.js

@@ -15,6 +15,8 @@ exports.withOutputStyleOption = withOutputStyleOption;
 exports.withRunOneOptions = withRunOneOptions;
 exports.parseCSV = parseCSV;
 exports.readParallelFromArgsAndEnv = readParallelFromArgsAndEnv;
+const nx_json_1 = require("../../config/nx-json");
+const is_tui_enabled_1 = require("../../tasks-runner/is-tui-enabled");
 exports.defaultYargsParserConfiguration = {
     'strip-dashed': true,
     'unknown-options-as-args': true,
@@ -229,23 +231,40 @@ function withOverrides(args, commandLevel = 1) {
     };
 }
 const allOutputStyles = [
+    'tui',
     'dynamic',
+    'dynamic-legacy',
     'static',
     'stream',
     'stream-without-prefixes',
     'compact',
 ];
 function withOutputStyleOption(yargs, choices = [
+    'dynamic-legacy',
     'dynamic',
+    'tui',
     'static',
     'stream',
     'stream-without-prefixes',
 ]) {
-    return yargs.option('output-style', {
-        describe: `Defines how Nx emits outputs tasks logs. **dynamic**: use dynamic output life cycle, previous content is overwritten or modified as new outputs are added, display minimal logs by default, always show errors. This output format is recommended on your local development environments. **static**: uses static output life cycle, no previous content is rewritten or modified as new outputs are added. This output format is recommened for CI environments. **stream**: nx by default logs output to an internal output stream, enable this option to stream logs to stdout / stderr. **stream-without-prefixes**: nx prefixes the project name the target is running on, use this option remove the project name prefix from output.`,
+    return yargs
+        .option('output-style', {
+        describe: `Defines how Nx emits outputs tasks logs. **tui**: enables the Nx Terminal UI, recommended for local development environments. **dynamic-legacy**: use dynamic-legacy output life cycle, previous content is overwritten or modified as new outputs are added, display minimal logs by default, always show errors. This output format is recommended for local development environments where tui is not supported. **static**: uses static output life cycle, no previous content is rewritten or modified as new outputs are added. This output format is recommened for CI environments. **stream**: nx by default logs output to an internal output stream, enable this option to stream logs to stdout / stderr. **stream-without-prefixes**: nx prefixes the project name the target is running on, use this option remove the project name prefix from output.`,
         type: 'string',
         choices,
-    });
+    })
+        .middleware([
+        (args) => {
+            const useTui = (0, is_tui_enabled_1.shouldUseTui)((0, nx_json_1.readNxJson)(), args);
+            if (useTui) {
+                // We have to set both of these because `check` runs after the normalization that
+                // handles the kebab-case'd args -> camelCase'd args translation.
+                args['output-style'] = 'tui';
+                args.outputStyle = 'tui';
+            }
+            process.env.NX_TUI = useTui.toString();
+        },
+    ]);
 }
 function withRunOneOptions(yargs) {
     const executorShouldShowHelp = !(process.argv[2] === 'run' && process.argv[3] === '--help');

package/src/config/nx-json.d.ts

@@ -165,13 +165,20 @@ export interface NxReleaseChangelogConfiguration {
      * NOTE: if createRelease is set on a group of projects, it will cause the default releaseTagPattern of
      * "{projectName}@{version}" to be used for those projects, even when versioning everything together.
      */
-    createRelease?: false | 'github' | {
+    createRelease?: false | 'github' | 'gitlab' | {
         provider: 'github-enterprise-server';
         hostname: string;
         /**
          * If not set, this will default to `https://${hostname}/api/v3`
          */
         apiBaseUrl?: string;
+    } | {
+        provider: 'gitlab';
+        hostname: string;
+        /**
+         * If not set, this will default to `https://${hostname}/api/v4`
+         */
+        apiBaseUrl?: string;
     };
     /**
      * This can either be set to a string value that will be written to the changelog file(s)