nx 21.0.0-canary.20250429-cf4a1f3 → 21.0.0-canary.20250501-8f50358

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/repair/repair.js

@@ -20,8 +20,8 @@ async function repair(args, extraMigrations = []) {
             return agg;
         }, []);
         const migrations = [...nxMigrations, ...extraMigrations];
-        const migrationsThatMadeNoChanges = await (0, migrate_1.executeMigrations)(process.cwd(), migrations, args.verbose, false, '');
-        if (migrationsThatMadeNoChanges.length < migrations.length) {
+        const { migrationsWithNoChanges, nextSteps } = await (0, migrate_1.executeMigrations)(process.cwd(), migrations, args.verbose, false, '');
+        if (migrationsWithNoChanges.length < migrations.length) {
             output_1.output.success({
                 title: `Successfully repaired your configuration. This workspace is up to date!`,
             });
@@ -31,5 +31,11 @@ async function repair(args, extraMigrations = []) {
                 title: `No changes were necessary. This workspace is up to date!`,
             });
         }
+        if (nextSteps.length) {
+            output_1.output.log({
+                title: 'Some repairs have additional information, see below.',
+                bodyLines: nextSteps.map((line) => `  - ${line}`),
+            });
+        }
     });
 }

package/src/command-line/report/report.js

@@ -182,7 +182,7 @@ async function getReportData() {
             nxKeyError = e;
         }
     }
-    let cache = (0, cache_1.dbCacheEnabled)(nxJson)
+    let cache = (0, cache_1.dbCacheEnabled)()
         ? {
             max: nxJson.maxCacheSize !== undefined
                 ? (0, cache_1.parseMaxCacheSize)(nxJson.maxCacheSize)

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/misc-interfaces.d.ts

@@ -3,7 +3,8 @@ import { ProjectGraph } from './project-graph';
 import { Task, TaskGraph } from './task-graph';
 import { TargetConfiguration, ProjectsConfigurations } from './workspace-json-project-json';
 import type { NxJsonConfiguration } from './nx-json';
-import { Schema } from '../utils/params';
+import type { Schema } from '../utils/params';
+import type { Tree } from '../generators/tree';
 /**
  * A callback function that is executed after changes are made to the file system
  */
@@ -50,6 +51,13 @@ export type PackageJsonUpdates = {
         requires?: Record<string, string>;
     };
 };
+/**
+ * Represents a migration that is executed when running `nx migrate`.
+ *
+ * Returning a string[] from the migration function will be interpreted as
+ * a list of next steps to be displayed to the user.
+ */
+export type Migration = (tree: Tree) => void | Promise<void> | string[] | Promise<string[]>;
 export interface MigrationsJsonEntry {
     version: string;
     description?: string;

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)
@@ -590,10 +597,6 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      * Configuration for the `nx sync` command.
      */
     sync?: NxSyncConfiguration;
-    /**
-     * Use the legacy file system cache instead of the db cache
-     */
-    useLegacyCache?: boolean;
     /**
      * Sets the maximum size of the local cache. Accepts a number followed by a unit (e.g. 100MB). Accepted units are B, KB, MB, and GB.
      */