nx 22.7.0-beta.0 → 22.7.0-beta.10

package/README.md

@@ -1,7 +1,7 @@
 <p style="text-align: center;">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
-    <img alt="Nx - Smart Monorepos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+    <img alt="Nx - Smart Repos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
   </picture>
 </p>
 
@@ -20,7 +20,7 @@
 
 <hr>
 
-# Nx: Smart Monorepos · Fast Builds
+# Nx: Smart Repos · Fast Builds
 
 Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
 

package/dist/bin/init-local.d.ts

@@ -0,0 +1,8 @@
+import { WorkspaceTypeAndRoot } from '../src/utils/find-workspace-root';
+/**
+ * Nx is being run inside a workspace.
+ *
+ * @param workspace Relevant local workspace properties
+ */
+export declare function initLocal(workspace: WorkspaceTypeAndRoot): Promise<void>;
+export declare function rewriteTargetsAndProjects(args: string[]): string[];

package/dist/bin/nx-cloud.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import type { CloudTaskRunnerOptions } from '../src/nx-cloud/nx-cloud-tasks-runner-shell';
+export declare function invokeCommandWithNxCloudClient(options: CloudTaskRunnerOptions): Promise<any>;

package/dist/bin/nx.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../src/utils/perf-logging';

package/dist/bin/nx.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+"use strict";
+// TODO: Remove this workaround once picocolors handles FORCE_COLOR=0 correctly
+// See: https://github.com/alexeyraspopov/picocolors/issues/100
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+if (process.env.FORCE_COLOR === '0') {
+    process.env.NO_COLOR = '1';
+    delete process.env.FORCE_COLOR;
+}
+const find_workspace_root_1 = require("../src/utils/find-workspace-root");
+const pc = tslib_1.__importStar(require("picocolors"));
+const dotenv_1 = require("../src/utils/dotenv");
+const init_local_1 = require("./init-local");
+const output_1 = require("../src/utils/output");
+const installation_directory_1 = require("../src/utils/installation-directory");
+const semver_1 = require("semver");
+const strip_indents_1 = require("../src/utils/strip-indents");
+const child_process_1 = require("child_process");
+const module_1 = require("module");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const assert_supported_platform_1 = require("../src/native/assert-supported-platform");
+const perf_hooks_1 = require("perf_hooks");
+const workspace_context_1 = require("../src/utils/workspace-context");
+const client_1 = require("../src/daemon/client/client");
+const db_connection_1 = require("../src/utils/db-connection");
+const analytics_prompt_1 = require("../src/utils/analytics-prompt");
+const analytics_1 = require("../src/analytics");
+require("../src/utils/perf-logging");
+const isTsExt = (0, path_1.extname)(__filename).endsWith('.ts');
+const pathToPkgJson = isTsExt ? '../package.json' : '../../package.json';
+async function main() {
+    if (process.argv[2] !== 'report' &&
+        process.argv[2] !== '--version' &&
+        process.argv[2] !== '--help' &&
+        process.argv[2] !== 'reset') {
+        (0, assert_supported_platform_1.assertSupportedPlatform)();
+    }
+    const workspace = (0, find_workspace_root_1.findWorkspaceRoot)(process.cwd());
+    if (workspace) {
+        perf_hooks_1.performance.mark('loading dotenv files:start');
+        (0, dotenv_1.loadRootEnvFiles)(workspace.dir);
+        perf_hooks_1.performance.mark('loading dotenv files:end');
+        perf_hooks_1.performance.measure('loading dotenv files', 'loading dotenv files:start', 'loading dotenv files:end');
+    }
+    // new is a special case because there is no local workspace to load
+    if (process.argv[2] === 'new' ||
+        process.argv[2] === '_migrate' ||
+        process.argv[2] === 'init' ||
+        process.argv[2] === 'configure-ai-agents' ||
+        (process.argv[2] === 'graph' && !workspace)) {
+        process.env.NX_DAEMON = 'false';
+        require('nx/src/command-line/nx-commands').commandsObject.argv;
+    }
+    else {
+        // polyfill rxjs observable to avoid issues with multiple version of Observable installed in node_modules
+        // https://twitter.com/BenLesh/status/1192478226385428483?s=20
+        if (!Symbol.observable)
+            Symbol.observable = Symbol('observable polyfill');
+        // Make sure that a local copy of Nx exists in workspace
+        let localNx;
+        try {
+            localNx = workspace && resolveNx(workspace);
+        }
+        catch {
+            localNx = null;
+        }
+        const isLocalInstall = localNx === resolveNx(null) || localNx === __filename;
+        const { LOCAL_NX_VERSION, GLOBAL_NX_VERSION } = determineNxVersions(localNx, workspace, isLocalInstall);
+        if (process.argv[2] === '--version') {
+            handleNxVersionCommand(LOCAL_NX_VERSION, GLOBAL_NX_VERSION);
+        }
+        if (!workspace && !isNxCloudCommand(process.argv[2])) {
+            handleNoWorkspace(GLOBAL_NX_VERSION);
+        }
+        if (!localNx && !isNxCloudCommand(process.argv[2])) {
+            handleMissingLocalInstallation(workspace ? workspace.dir : null);
+        }
+        // this file is already in the local workspace
+        if (isNxCloudCommand(process.argv[2])) {
+            if (!client_1.daemonClient.enabled() && workspace !== null) {
+                (0, workspace_context_1.setupWorkspaceContext)(workspace.dir);
+            }
+            await initAnalytics();
+            // nx-cloud commands can run without local Nx installation
+            process.env.NX_DAEMON = 'false';
+            require('nx/src/command-line/nx-commands').commandsObject.argv;
+        }
+        else if (isLocalInstall) {
+            if (!client_1.daemonClient.enabled() && workspace !== null) {
+                (0, workspace_context_1.setupWorkspaceContext)(workspace.dir);
+            }
+            await initAnalytics();
+            await (0, init_local_1.initLocal)(workspace);
+        }
+        else if (localNx) {
+            // Nx is being run from globally installed CLI - hand off to the local
+            // Don't start analytics, connect to the DB, or set up the workspace
+            // context here — the local Nx will handle it when it runs its own bin/nx.ts
+            warnIfUsingOutdatedGlobalInstall(GLOBAL_NX_VERSION, LOCAL_NX_VERSION);
+            if (localNx.includes('.nx')) {
+                const nxWrapperPath = localNx.replace(/\.nx.*/, '.nx/') + 'nxw.js';
+                require(nxWrapperPath);
+            }
+            else {
+                require(localNx);
+            }
+        }
+    }
+}
+function handleNoWorkspace(globalNxVersion) {
+    output_1.output.log({
+        title: `The current directory isn't part of an Nx workspace.`,
+        bodyLines: [
+            `To create a workspace run:`,
+            pc.bold(pc.white(`npx create-nx-workspace@latest <workspace name>`)),
+            '',
+            `To add Nx to an existing workspace with a workspace-specific nx.json, run:`,
+            pc.bold(pc.white(`npx nx@latest init`)),
+        ],
+    });
+    output_1.output.note({
+        title: `For more information please visit https://nx.dev/`,
+    });
+    warnIfUsingOutdatedGlobalInstall(globalNxVersion);
+    process.exit(1);
+}
+function handleNxVersionCommand(LOCAL_NX_VERSION, GLOBAL_NX_VERSION) {
+    console.log((0, strip_indents_1.stripIndents) `Nx Version:
+      - Local: ${LOCAL_NX_VERSION ? 'v' + LOCAL_NX_VERSION : 'Not found'}
+      - Global: ${GLOBAL_NX_VERSION ? 'v' + GLOBAL_NX_VERSION : 'Not found'}`);
+    process.exit(0);
+}
+function determineNxVersions(localNx, workspace, isLocalInstall) {
+    const LOCAL_NX_VERSION = localNx
+        ? getLocalNxVersion(workspace)
+        : null;
+    const GLOBAL_NX_VERSION = isLocalInstall
+        ? null
+        : require(pathToPkgJson).version;
+    globalThis.GLOBAL_NX_VERSION ??= GLOBAL_NX_VERSION;
+    return { LOCAL_NX_VERSION, GLOBAL_NX_VERSION };
+}
+function resolveNx(workspace) {
+    // root relative to location of the nx bin
+    const globalsRoot = (0, path_1.join)(__dirname, '../../../../');
+    const root = workspace ? workspace.dir : globalsRoot;
+    // Use createRequire to resolve from outside the nx package,
+    // avoiding self-referencing caused by the exports field
+    // prefer Nx installed in .nx/installation
+    try {
+        const installPath = (0, installation_directory_1.getNxInstallationPath)(root);
+        if ((0, fs_1.existsSync)(installPath)) {
+            const installRequire = (0, module_1.createRequire)((0, path_1.join)(installPath, 'package.json'));
+            return installRequire.resolve('nx/bin/nx.js');
+        }
+    }
+    catch { }
+    // check for root install
+    const rootRequire = (0, module_1.createRequire)((0, path_1.join)(root, 'package.json'));
+    return rootRequire.resolve('nx/bin/nx.js');
+}
+function isNxCloudCommand(command) {
+    const nxCloudCommands = [
+        'start-ci-run',
+        'start-agent',
+        'stop-all-agents',
+        'complete-ci-run',
+        'login',
+        'logout',
+        'connect',
+        'view-logs',
+        'fix-ci',
+        'record',
+        'polygraph',
+        'download-cloud-client',
+    ];
+    return nxCloudCommands.includes(command);
+}
+async function initAnalytics() {
+    try {
+        await (0, analytics_prompt_1.ensureAnalyticsPreferenceSet)();
+    }
+    catch { }
+    await (0, analytics_1.startAnalytics)();
+}
+function handleMissingLocalInstallation(detectedWorkspaceRoot) {
+    output_1.output.error({
+        title: detectedWorkspaceRoot
+            ? `Could not find Nx modules at "${detectedWorkspaceRoot}".`
+            : `Could not find Nx modules in this workspace.`,
+        bodyLines: [`Have you run ${pc.bold(pc.white(`npm/yarn install`))}?`],
+    });
+    process.exit(1);
+}
+/**
+ * Assumes currently running Nx is global install.
+ * Warns if out of date by 1 major version or more.
+ */
+function warnIfUsingOutdatedGlobalInstall(globalNxVersion, localNxVersion) {
+    // Never display this warning if Nx is already running via Nx
+    if (process.env.NX_CLI_SET) {
+        return;
+    }
+    const isOutdatedGlobalInstall = checkOutdatedGlobalInstallation(globalNxVersion, localNxVersion);
+    // Using a global Nx Install
+    if (isOutdatedGlobalInstall) {
+        const bodyLines = localNxVersion
+            ? [
+                `Your repository uses a higher version of Nx (${localNxVersion}) than your global CLI version (${globalNxVersion})`,
+            ]
+            : [];
+        bodyLines.push('For more information, see https://nx.dev/more-concepts/global-nx');
+        output_1.output.warn({
+            title: `It's time to update Nx 🎉`,
+            bodyLines,
+        });
+    }
+}
+function checkOutdatedGlobalInstallation(globalNxVersion, localNxVersion) {
+    // We aren't running a global install, so we can't know if its outdated.
+    if (!globalNxVersion) {
+        return false;
+    }
+    if (localNxVersion) {
+        // If the global Nx install is at least a major version behind the local install, warn.
+        return (0, semver_1.major)(globalNxVersion) < (0, semver_1.major)(localNxVersion);
+    }
+    // No local installation was detected. This can happen if the user is running a global install
+    // that contains an older version of Nx, which is unable to detect the local installation. The most
+    // recent case where this would have happened would be when we stopped generating workspace.json by default,
+    // as older global installations used it to determine the workspace root. This only be hit in rare cases,
+    // but can provide valuable insights for troubleshooting.
+    const latestVersionOfNx = getLatestVersionOfNx();
+    if (latestVersionOfNx && (0, semver_1.major)(globalNxVersion) < (0, semver_1.major)(latestVersionOfNx)) {
+        return true;
+    }
+}
+function getLocalNxVersion(workspace) {
+    try {
+        const searchPaths = (0, installation_directory_1.getNxRequirePaths)(workspace.dir);
+        for (const searchPath of searchPaths) {
+            if (!(0, fs_1.existsSync)(searchPath)) {
+                continue;
+            }
+            try {
+                const externalRequire = (0, module_1.createRequire)((0, path_1.join)(searchPath, 'package.json'));
+                const pkgJsonPath = externalRequire.resolve('nx/package.json');
+                return require(pkgJsonPath).version;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return null;
+}
+function _getLatestVersionOfNx() {
+    try {
+        return (0, child_process_1.execSync)('npm view nx@latest version', {
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        try {
+            return (0, child_process_1.execSync)('pnpm view nx@latest version', {
+                windowsHide: true,
+            })
+                .toString()
+                .trim();
+        }
+        catch {
+            return null;
+        }
+    }
+}
+const getLatestVersionOfNx = ((fn) => {
+    let cache = null;
+    return () => cache || (cache = fn());
+})(_getLatestVersionOfNx);
+process.on('exit', () => {
+    (0, db_connection_1.removeDbConnections)();
+});
+main().catch((error) => {
+    console.error(error);
+    (0, analytics_1.flushAnalytics)();
+    process.exit(1);
+});

package/dist/bin/post-install.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin/run-executor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugins/package-json.d.ts

@@ -0,0 +1,4 @@
+import { ProjectConfiguration } from '../src/config/workspace-json-project-json';
+import { PluginCache } from '../src/utils/plugin-cache-utils';
+export type PackageJsonConfigurationCache = PluginCache<ProjectConfiguration>;
+export declare function readPackageJsonConfigurationCache(): PackageJsonConfigurationCache;

package/dist/release/changelog-renderer/index.d.ts

@@ -0,0 +1,109 @@
+import type { ChangelogChange } from '../../src/command-line/release/changelog';
+import type { NxReleaseConfig } from '../../src/command-line/release/config/config';
+import type { RemoteReleaseClient } from '../../src/command-line/release/utils/remote-release-clients/remote-release-client';
+/**
+ * Re-export for ease of use in custom changelog renderers.
+ */
+export type { ChangelogChange };
+/**
+ * The ChangelogRenderOptions are specific to each ChangelogRenderer implementation, and are taken
+ * from the user's nx.json configuration and passed as is into the ChangelogRenderer function.
+ */
+export type ChangelogRenderOptions = Record<string, unknown>;
+/**
+ * When versioning projects independently and enabling `"updateDependents": "auto"`, there could
+ * be additional dependency bump information that is not captured in the commit data, but that nevertheless
+ * should be included in the rendered changelog.
+ */
+export type DependencyBump = {
+    dependencyName: string;
+    newVersion: string;
+};
+/**
+ * The specific options available to the default implementation of the ChangelogRenderer that nx exports
+ * for the common case.
+ */
+export interface DefaultChangelogRenderOptions extends ChangelogRenderOptions {
+    /**
+     * Whether or not the commit authors should be added to the bottom of the changelog in a "Thank You"
+     * section. Defaults to true.
+     */
+    authors?: boolean;
+    /**
+     * If authors is enabled, controls whether or not to try to map the authors to their GitHub usernames
+     * using https://ungh.cc (from https://github.com/unjs/ungh) and, if needed, the GitHub search API via
+     * the gh CLI and the email addresses found in the commits.
+     * Defaults to true.
+     */
+    applyUsernameToAuthors?: boolean;
+    /**
+     * Whether or not the commit references (such as commit and/or PR links) should be included in the changelog.
+     * Defaults to true.
+     */
+    commitReferences?: boolean;
+    /**
+     * Whether or not to include the date in the version title. It can be set to false to disable it, or true to enable
+     * with the default of (YYYY-MM-DD). Defaults to true.
+     */
+    versionTitleDate?: boolean;
+}
+export default class DefaultChangelogRenderer {
+    protected changes: ChangelogChange[];
+    protected changelogEntryVersion: string;
+    protected project: string | null;
+    protected entryWhenNoChanges: string | false;
+    protected changelogRenderOptions: DefaultChangelogRenderOptions;
+    protected isVersionPlans: boolean;
+    protected dependencyBumps?: DependencyBump[];
+    protected conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'];
+    protected relevantChanges: ChangelogChange[];
+    protected breakingChanges: string[];
+    protected additionalChangesForAuthorsSection: ChangelogChange[];
+    protected remoteReleaseClient: RemoteReleaseClient<unknown>;
+    /**
+     * A ChangelogRenderer class takes in the determined changes and other relevant metadata
+     * and returns a string, or a Promise of a string of changelog contents (usually markdown).
+     *
+     * @param {Object} config The configuration object for the ChangelogRenderer
+     * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+     * @param {string} config.changelogEntryVersion The version for which we are rendering the current changelog entry
+     * @param {string | null} config.project The name of specific project to generate a changelog entry for, or `null` if the overall workspace changelog
+     * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
+     * @param {boolean} config.isVersionPlans Whether or not Nx release version plans are the source of truth for the changelog entry
+     * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
+     * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the change data
+     * @param {NxReleaseConfig['conventionalCommits']} config.conventionalCommitsConfig The configuration for conventional commits
+     * @param {RemoteReleaseClient} config.remoteReleaseClient The remote release client to use for formatting references
+     */
+    constructor(config: {
+        changes: ChangelogChange[];
+        changelogEntryVersion: string;
+        project: string | null;
+        entryWhenNoChanges: string | false;
+        isVersionPlans: boolean;
+        changelogRenderOptions: DefaultChangelogRenderOptions;
+        dependencyBumps?: DependencyBump[];
+        conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'];
+        remoteReleaseClient: RemoteReleaseClient<unknown>;
+    });
+    protected filterChanges(changes: ChangelogChange[], project: string | null): ChangelogChange[];
+    render(): Promise<string>;
+    protected preprocessChanges(): void;
+    protected shouldRenderEmptyEntry(): boolean;
+    protected renderEmptyEntry(): string;
+    protected renderVersionTitle(): string;
+    protected renderChangesByType(): string[];
+    protected hasBreakingChanges(): boolean;
+    protected renderBreakingChanges(): string[];
+    protected hasDependencyBumps(): boolean;
+    protected renderDependencyBumps(): string[];
+    protected shouldRenderAuthors(): boolean;
+    protected renderAuthors(): Promise<string[]>;
+    protected formatChange(change: ChangelogChange): string;
+    protected formatBreakingChangeBase(change: ChangelogChange): string;
+    protected formatBreakingChange(change: ChangelogChange): string;
+    protected groupChangesByType(): Record<string, ChangelogChange[]>;
+    protected groupChangesByScope(changes: ChangelogChange[]): Record<string, ChangelogChange[]>;
+    protected extractBreakingChangeExplanation(message: string): string | null;
+    protected formatName(name?: string): string;
+}

package/dist/release/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @public Programmatic API for nx release
+ */
+export { ReleaseClient, release, releaseChangelog, releasePublish, releaseVersion, VersionActions, AfterAllProjectsVersioned, } from '../src/command-line/release';