nx 21.0.0-beta.1 → 21.0.0-beta.10

package/src/command-line/run/executor-utils.d.ts

@@ -1,7 +1,12 @@
 import { ExecutorConfig } from '../../config/misc-interfaces';
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 export declare function normalizeExecutorSchema(schema: Partial<ExecutorConfig['schema']>): ExecutorConfig['schema'];
-export declare function getExecutorInformation(nodeModule: string, executor: string, root: string, projects: Record<string, ProjectConfiguration>): ExecutorConfig & {
+export declare function parseExecutor(executorString: string): [module: string, name: string];
+export declare function getExecutorInformation(nodeModule: string, executor: string, root: string, 
+/**
+ * A map of projects keyed by project name
+ */
+projects: Record<string, ProjectConfiguration>): ExecutorConfig & {
     isNgCompat: boolean;
     isNxExecutor: boolean;
 };

package/src/command-line/run/executor-utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeExecutorSchema = normalizeExecutorSchema;
+exports.parseExecutor = parseExecutor;
 exports.getExecutorInformation = getExecutorInformation;
 const path_1 = require("path");
 const plugins_1 = require("../../project-graph/plugins");
@@ -12,6 +13,7 @@ function normalizeExecutorSchema(schema) {
     return {
         version,
         outputCapture: schema.outputCapture ?? version < 2 ? 'direct-nodejs' : 'pipe',
+        continuous: schema.continuous ?? false,
         properties: !schema.properties || typeof schema.properties !== 'object'
             ? {}
             : schema.properties,
@@ -21,8 +23,15 @@ function normalizeExecutorSchema(schema) {
 function cacheKey(nodeModule, executor, root) {
     return `${root}:${nodeModule}:${executor}`;
 }
+function parseExecutor(executorString) {
+    return executorString.split(':');
+}
 const cachedExecutorInformation = {};
-function getExecutorInformation(nodeModule, executor, root, projects) {
+function getExecutorInformation(nodeModule, executor, root, 
+/**
+ * A map of projects keyed by project name
+ */
+projects) {
     try {
         const key = cacheKey(nodeModule, executor, root);
         if (cachedExecutorInformation[key])

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

@@ -45,7 +45,7 @@ async function parseExecutorAndTarget({ project, target }, root, projectsConfigu
     if (!targetConfig) {
         throw new Error(`Cannot find target '${target}' for project '${project}'`);
     }
-    const [nodeModule, executor] = targetConfig.executor.split(':');
+    const [nodeModule, executor] = (0, executor_utils_1.parseExecutor)(targetConfig.executor);
     const { schema, implementationFactory } = (0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root, projectsConfigurations.projects);
     return { executor, implementationFactory, nodeModule, schema, targetConfig };
 }
@@ -66,7 +66,7 @@ async function printTargetRunHelpInternal({ project, target }, root, projectsCon
             ...localEnv,
         };
         if (pseudo_terminal_1.PseudoTerminal.isSupported()) {
-            const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
+            const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
             await new Promise(() => {
                 const cp = terminal.runCommand(helpCommand, { jsEnv: env });
                 cp.onExit((code) => {

package/src/command-line/run-many/command-object.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsRunManyCommand = void 0;
+const handle_errors_1 = require("../../utils/handle-errors");
 const documentation_1 = require("../yargs-utils/documentation");
 const shared_options_1 = require("../yargs-utils/shared-options");
-const handle_errors_1 = require("../../utils/handle-errors");
 exports.yargsRunManyCommand = {
     command: 'run-many',
     describe: 'Run target for multiple listed projects.',
-    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withRunManyOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withTargetAndConfigurationOption)((0, shared_options_1.withBatch)(yargs)))), 'run-many'),
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withTuiOptions)((0, shared_options_1.withRunManyOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withTargetAndConfigurationOption)((0, shared_options_1.withBatch)(yargs))))), 'run-many'),
     handler: async (args) => {
         const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
             await Promise.resolve().then(() => require('./run-many')).then((m) => m.runMany((0, shared_options_1.withOverrides)(args)));

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

@@ -23,6 +23,10 @@ export interface RunOptions {
     excludeTaskDependencies: boolean;
     skipSync: boolean;
 }
+export interface TuiOptions {
+    tuiAutoExit: boolean | number;
+}
+export declare function withTuiOptions<T>(yargs: Argv<T>): Argv<T & TuiOptions>;
 export declare function withRunOptions<T>(yargs: Argv<T>): Argv<T & RunOptions>;
 export declare function withTargetAndConfigurationOption(yargs: Argv, demandOption?: boolean): Argv<{
     configuration: string;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultYargsParserConfiguration = void 0;
 exports.withExcludeOption = withExcludeOption;
+exports.withTuiOptions = withTuiOptions;
 exports.withRunOptions = withRunOptions;
 exports.withTargetAndConfigurationOption = withTargetAndConfigurationOption;
 exports.withConfiguration = withConfiguration;
@@ -28,6 +29,25 @@ function withExcludeOption(yargs) {
         coerce: parseCSV,
     });
 }
+function withTuiOptions(yargs) {
+    return yargs.options('tuiAutoExit', {
+        describe: 'Whether or not to exit the TUI automatically after all tasks finish, and after how long. If set to `true`, the TUI will exit immediately. If set to `false` the TUI will not automatically exit. If set to a number, an interruptible countdown popup will be shown for that many seconds before the TUI exits.',
+        type: 'string',
+        coerce: (value) => {
+            if (value === 'true') {
+                return true;
+            }
+            if (value === 'false') {
+                return false;
+            }
+            const num = Number(value);
+            if (!Number.isNaN(num)) {
+                return num;
+            }
+            throw new Error(`Invalid value for --tui-auto-exit: ${value}`);
+        },
+    });
+}
 function withRunOptions(yargs) {
     return withVerbose(withExcludeOption(yargs))
         .option('parallel', {

package/src/config/misc-interfaces.d.ts

@@ -53,11 +53,20 @@ export type PackageJsonUpdates = {
 export interface MigrationsJsonEntry {
     version: string;
     description?: string;
-    cli?: string;
     implementation?: string;
     factory?: string;
     requires?: Record<string, string>;
 }
+export type MigrationDetailsWithId = GeneratedMigrationDetails & {
+    id: string;
+};
+export interface GeneratedMigrationDetails {
+    name: string;
+    version: string;
+    package: string;
+    description: string;
+    implementation: string;
+}
 export interface MigrationsJson {
     name?: string;
     version?: string;
@@ -83,6 +92,7 @@ export interface ExecutorConfig {
     schema: {
         version?: number;
         outputCapture?: OutputCaptureMethod;
+        continuous?: boolean;
     } & Schema;
     hasherFactory?: () => CustomHasher;
     implementationFactory: () => Executor;

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

@@ -1,6 +1,7 @@
 import type { ChangelogRenderOptions } from '../../release/changelog-renderer';
-import { PackageManager } from '../utils/package-manager';
-import { InputDefinition, TargetConfiguration, TargetDependencyConfig } from './workspace-json-project-json';
+import type { validReleaseVersionPrefixes } from '../command-line/release/version';
+import type { PackageManager } from '../utils/package-manager';
+import type { InputDefinition, TargetConfiguration, TargetDependencyConfig } from './workspace-json-project-json';
 export type ImplicitDependencyEntry<T = '*' | string[]> = {
     [key: string]: T | ImplicitJsonSubsetDependency<T>;
 };
@@ -35,7 +36,13 @@ interface NxInstallationConfiguration {
      */
     plugins?: Record<string, string>;
 }
-export interface NxReleaseVersionConfiguration {
+/**
+ * This named configuration interface represents the options prior to Nx v21. This interface will be made available
+ * under LegacyNxReleaseVersionConfiguration throughout the lifetime of Nx v21.
+ *
+ * In Nx v22, this configuration interface will no longer be valid.
+ */
+export interface LegacyNxReleaseVersionConfiguration {
     generator?: string;
     generatorOptions?: Record<string, unknown>;
     /**
@@ -50,6 +57,106 @@ export interface NxReleaseVersionConfiguration {
      */
     conventionalCommits?: boolean;
 }
+export type ManifestRootToUpdate = string | {
+    path: string;
+    preserveLocalDependencyProtocols: boolean;
+};
+export interface NxReleaseVersionConfiguration {
+    /**
+     * Whether to use the legacy versioning strategy. This value was true in Nx v20 and became false in Nx v21.
+     * The legacy versioning implementation will be removed in Nx v22, as will this flag.
+     */
+    useLegacyVersioning?: boolean;
+    /**
+     * Shorthand for enabling the current version of projects to be resolved from git tags,
+     * and the next version to be determined by analyzing commit messages according to the
+     * Conventional Commits specification.
+     */
+    conventionalCommits?: boolean;
+    /**
+     * A command to run after validation of nx release configuration, but before versioning begins.
+     * Useful for preparing build artifacts. If --dry-run is passed, the command is still executed,
+     * but with the NX_DRY_RUN environment variable set to 'true'.
+     */
+    preVersionCommand?: string;
+    /**
+     * The source to use for determining the specifier to use when versioning.
+     * 'prompt' is the default and will interactively prompt the user for an explicit/imperative specifier.
+     * 'conventional-commits' will attempt determine a specifier from commit messages conforming to the Conventional Commits specification.
+     * 'version-plans' will determine the specifier from the version plan files available on disk.
+     */
+    specifierSource?: 'prompt' | 'conventional-commits' | 'version-plans';
+    /**
+     * A list of directories containing manifest files (such as package.json) to apply updates to when versioning.
+     *
+     * By default, only the project root will be used, but you could customize this to only version a manifest in a
+     * dist directory, or even version multiple manifests in different directories, such as both source and dist.
+     *
+     * For more advanced scenarios, the preserveLocalDependencyProtocols can be overridden per manifest by providing
+     * and object instead of a string.
+     */
+    manifestRootsToUpdate?: ManifestRootToUpdate[];
+    /**
+     * The resolver to use for determining the current version of a project during versioning.
+     * This is needed for versioning approaches which involve relatively modifying a current version
+     * to arrive at a new version, such as semver bumps like 'patch', 'minor' etc.
+     *
+     * Using 'none' explicitly declares that the current version is not needed to compute the new version, and
+     * should only be used with appropriate version actions implementations that support it.
+     */
+    currentVersionResolver?: 'registry' | 'disk' | 'git-tag' | 'none';
+    /**
+     * Metadata to provide to the configured currentVersionResolver to help it in determining the current version.
+     * What to pass here is specific to each resolver.
+     */
+    currentVersionResolverMetadata?: Record<string, unknown>;
+    /**
+     * The fallback version resolver to use when the configured currentVersionResolver fails to resolve the current version.
+     */
+    fallbackCurrentVersionResolver?: 'disk';
+    /**
+     * Whether or not this is the first release of one of more projects.
+     * This removes certain validation checks that are not possible to enforce if the project has never been released before.
+     */
+    firstRelease?: boolean;
+    /**
+     * The prefix to use when versioning dependencies.
+     * This can be one of the following: auto, '', '~', '^', '=', where auto means the existing prefix will be preserved.
+     */
+    versionPrefix?: (typeof validReleaseVersionPrefixes)[number];
+    /**
+     * Whether to delete the processed version plans file after versioning is complete. This is false by default because the
+     * version plans are also needed for changelog generation.
+     */
+    deleteVersionPlans?: boolean;
+    /**
+     * When versioning independent projects, this controls whether to update their dependents (i.e. the things that depend on them).
+     * 'never' means no dependents will be updated (unless they happen to be versioned directly as well).
+     * 'auto' is the default and will cause dependents to be updated (a patch version bump) when a dependency is versioned.
+     */
+    updateDependents?: 'auto' | 'never';
+    /**
+     * Whether to log projects that have not changed during versioning.
+     */
+    logUnchangedProjects?: boolean;
+    /**
+     * The path to the version actions implementation to use for releasing all projects by default.
+     * This can also be overridden on the release group and project levels.
+     */
+    versionActions?: string;
+    /**
+     * The specific options that are defined by each version actions implementation.
+     * They will be passed to the version actions implementation when running a release.
+     */
+    versionActionsOptions?: Record<string, unknown>;
+    /**
+     * Whether to preserve local dependency protocols (e.g. file references, or the `workspace:` protocol in package.json files)
+     * of local dependencies when updating them during versioning.
+     *
+     * This was false by default in legacy versioning, but is true by default now.
+     */
+    preserveLocalDependencyProtocols?: boolean;
+}
 export interface NxReleaseChangelogConfiguration {
     /**
      * Optionally create a release containing all relevant changes on a supported version control system, it
@@ -131,6 +238,10 @@ export interface NxReleaseGitConfiguration {
      * Whether or not to automatically push the changes made by this command to the remote git repository.
      */
     push?: boolean;
+    /**
+     * Additional arguments to pass to the `git push` command invoked behind the scenes. May be a string or array of strings.
+     */
+    pushArgs?: string | string[];
 }
 export interface NxReleaseConventionalCommitsConfiguration {
     types?: Record<string, 
@@ -190,7 +301,7 @@ export interface NxReleaseConfiguration {
          *
          * NOTE: git configuration is not supported at the group level, only the root/command level
          */
-        version?: NxReleaseVersionConfiguration & {
+        version?: (LegacyNxReleaseVersionConfiguration | NxReleaseVersionConfiguration) & {
             /**
              * A command to run after validation of nx release configuration, but before versioning begins.
              * Used for preparing build artifacts. If --dry-run is passed, the command is still executed, but
@@ -215,6 +326,15 @@ export interface NxReleaseConfiguration {
          * Optionally override the git/release tag pattern to use for this group.
          */
         releaseTagPattern?: string;
+        /**
+         * By default, we will try and resolve the latest match for the releaseTagPattern from the current branch,
+         * falling back to all branches if no match is found on the current branch.
+         *
+         * - Setting this to true will cause us to ALWAYS check all branches for the latest match.
+         * - Setting it to false will cause us to ONLY check the current branch for the latest match.
+         * - Setting it to an array of strings will cause us to check all branches WHEN the current branch matches one of the strings in the array. Glob patterns are supported.
+         */
+        releaseTagPatternCheckAllBranchesWhen?: boolean | string[];
         /**
          * Enables using version plans as a specifier source for versioning and
          * to determine changes for changelog generation.
@@ -255,19 +375,12 @@ export interface NxReleaseConfiguration {
         automaticFromRef?: boolean;
     };
     /**
-     * If no version config is provided, we will assume that @nx/js:release-version
-     * is the desired generator implementation, allowing for terser config for the common case.
+     * If no version configuration is provided, we will assume that TypeScript/JavaScript experience is what is desired,
+     * allowing for terser release configuration for the common case.
      */
-    version?: NxReleaseVersionConfiguration & {
-        /**
-         * Enable or override configuration for git operations as part of the version subcommand
-         */
+    version?: (LegacyNxReleaseVersionConfiguration | NxReleaseVersionConfiguration) & {
+        useLegacyVersioning?: boolean;
         git?: NxReleaseGitConfiguration;
-        /**
-         * A command to run after validation of nx release configuration, but before versioning begins.
-         * Used for preparing build artifacts. If --dry-run is passed, the command is still executed, but
-         * with the NX_DRY_RUN environment variable set to 'true'.
-         */
         preVersionCommand?: string;
     };
     /**
@@ -281,6 +394,15 @@ export interface NxReleaseConfiguration {
      * The default releaseTagPattern for independent releases at the project level is: "{projectName}@{version}"
      */
     releaseTagPattern?: string;
+    /**
+     * By default, we will try and resolve the latest match for the releaseTagPattern from the current branch,
+     * falling back to all branches if no match is found on the current branch.
+     *
+     * - Setting this to true will cause us to ALWAYS check all branches for the latest match.
+     * - Setting it to false will cause us to ONLY check the current branch for the latest match.
+     * - Setting it to an array of strings will cause us to check all branches WHEN the current branch matches one of the strings in the array. Glob patterns are supported.
+     */
+    releaseTagPatternCheckAllBranchesWhen?: boolean | string[];
     /**
      * Enable and configure automatic git operations as part of the release
      */
@@ -321,6 +443,7 @@ export interface NxSyncConfiguration {
  * @note: when adding properties here add them to `allowedWorkspaceExtensions` in adapter/compat.ts
  */
 export interface NxJsonConfiguration<T = '*' | string[]> {
+    $schema?: string;
     /**
      * Optional (additional) Nx.json configuration file which becomes a base for this one
      */
@@ -357,7 +480,7 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
         appsDir?: string;
     };
     /**
-     * @deprecated Custom task runners will no longer be supported in Nx 21. Use Nx Cloud or Nx Powerpack instead.
+     * @deprecated Custom task runners will be replaced by a new API starting with Nx 21. More info: https://nx.dev/deprecated/custom-tasks-runner
      * Available Task Runners for Nx to use
      */
     tasksRunnerOptions?: {
@@ -471,6 +594,27 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      * 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.
+     */
+    maxCacheSize?: string;
+    /**
+     * Settings for the Nx Terminal User Interface (TUI)
+     */
+    tui?: {
+        /**
+         * Whether to enable the TUI whenever possible (based on the current environment and terminal).
+         */
+        enabled?: boolean;
+        /**
+         * Whether to exit the TUI automatically after all tasks finish.
+         *
+         * - If set to `true`, the TUI will exit immediately.
+         * - If set to `false` the TUI will not automatically exit.
+         * - If set to a number, an interruptible countdown popup will be shown for that many seconds before the TUI exits.
+         */
+        autoExit?: boolean | number;
+    };
 }
 export type PluginConfiguration = string | ExpandedPluginConfiguration;
 export type ExpandedPluginConfiguration<T = unknown> = {

package/src/config/project-graph.d.ts

@@ -74,6 +74,7 @@ export interface ProjectGraphProjectNode {
         description?: string;
     };
 }
+export declare function isProjectGraphProjectNode(node: ProjectGraphProjectNode | ProjectGraphExternalNode): node is ProjectGraphProjectNode;
 /**
  * A node describing an external dependency
  * `name` has as form of:
@@ -85,14 +86,15 @@ export interface ProjectGraphProjectNode {
  *
  */
 export interface ProjectGraphExternalNode {
-    type: 'npm';
-    name: `npm:${string}`;
+    type: string;
+    name: string;
     data: {
         version: string;
         packageName: string;
         hash?: string;
     };
 }
+export declare function isProjectGraphExternalNode(node: ProjectGraphProjectNode | ProjectGraphExternalNode): node is ProjectGraphExternalNode;
 /**
  * A dependency between two projects
  */

package/src/config/project-graph.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DependencyType = void 0;
 exports.fileDataDepTarget = fileDataDepTarget;
 exports.fileDataDepType = fileDataDepType;
+exports.isProjectGraphProjectNode = isProjectGraphProjectNode;
+exports.isProjectGraphExternalNode = isProjectGraphExternalNode;
 function fileDataDepTarget(dep) {
     return typeof dep === 'string'
         ? dep
@@ -35,3 +37,9 @@ var DependencyType;
      */
     DependencyType["implicit"] = "implicit";
 })(DependencyType || (exports.DependencyType = DependencyType = {}));
+function isProjectGraphProjectNode(node) {
+    return node.type === 'app' || node.type === 'e2e' || node.type === 'lib';
+}
+function isProjectGraphExternalNode(node) {
+    return isProjectGraphProjectNode(node) === false;
+}

package/src/config/workspace-json-project-json.d.ts

@@ -1,5 +1,5 @@
 import type { PackageJson } from '../utils/package-json';
-import type { NxJsonConfiguration, NxReleaseVersionConfiguration } from './nx-json';
+import type { LegacyNxReleaseVersionConfiguration, NxJsonConfiguration, NxReleaseVersionConfiguration } from './nx-json';
 /**
  * @deprecated use ProjectsConfigurations or NxJsonConfiguration
  */
@@ -98,7 +98,7 @@ export interface ProjectConfiguration {
      * Project specific configuration for `nx release`
      */
     release?: {
-        version?: Pick<NxReleaseVersionConfiguration, 'generator' | 'generatorOptions'>;
+        version?: Pick<LegacyNxReleaseVersionConfiguration, 'generator' | 'generatorOptions'> | Pick<NxReleaseVersionConfiguration, 'versionActions' | 'versionActionsOptions' | 'manifestRootsToUpdate' | 'currentVersionResolver' | 'currentVersionResolverMetadata' | 'fallbackCurrentVersionResolver' | 'versionPrefix' | 'preserveLocalDependencyProtocols'>;
     };
     /**
      * Metadata about the project