nx 19.4.1 → 19.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.4.1",
+  "version": "19.4.3",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -70,7 +70,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.4.1"
+    "@nrwl/tao": "19.4.3"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -85,16 +85,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.4.1",
-    "@nx/nx-darwin-arm64": "19.4.1",
-    "@nx/nx-linux-x64-gnu": "19.4.1",
-    "@nx/nx-linux-x64-musl": "19.4.1",
-    "@nx/nx-win32-x64-msvc": "19.4.1",
-    "@nx/nx-linux-arm64-gnu": "19.4.1",
-    "@nx/nx-linux-arm64-musl": "19.4.1",
-    "@nx/nx-linux-arm-gnueabihf": "19.4.1",
-    "@nx/nx-win32-arm64-msvc": "19.4.1",
-    "@nx/nx-freebsd-x64": "19.4.1"
+    "@nx/nx-darwin-x64": "19.4.3",
+    "@nx/nx-darwin-arm64": "19.4.3",
+    "@nx/nx-linux-x64-gnu": "19.4.3",
+    "@nx/nx-linux-x64-musl": "19.4.3",
+    "@nx/nx-win32-x64-msvc": "19.4.3",
+    "@nx/nx-linux-arm64-gnu": "19.4.3",
+    "@nx/nx-linux-arm64-musl": "19.4.3",
+    "@nx/nx-linux-arm-gnueabihf": "19.4.3",
+    "@nx/nx-win32-arm64-msvc": "19.4.3",
+    "@nx/nx-freebsd-x64": "19.4.3"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

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

@@ -13,6 +13,7 @@ const semver_1 = require("semver");
 const installed_plugins_1 = require("../../utils/plugins/installed-plugins");
 const installation_directory_1 = require("../../utils/installation-directory");
 const nx_json_1 = require("../../config/nx-json");
+const error_types_1 = require("../../project-graph/error-types");
 const nxPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(__dirname, '../../../package.json'));
 exports.packagesWeCareAbout = [
     'lerna',
@@ -93,19 +94,11 @@ exports.reportHandler = reportHandler;
 async function getReportData() {
     const pm = (0, package_manager_1.detectPackageManager)();
     const pmVersion = (0, package_manager_1.getPackageManagerVersion)(pm);
+    const { graph, error: projectGraphError } = await tryGetProjectGraph();
     const nxJson = (0, nx_json_1.readNxJson)();
-    const localPlugins = await findLocalPlugins(nxJson);
+    const localPlugins = await findLocalPlugins(graph, nxJson);
     const communityPlugins = findInstalledCommunityPlugins();
     const registeredPlugins = findRegisteredPluginsBeingUsed(nxJson);
-    let projectGraphError = null;
-    if (isNativeAvailable()) {
-        try {
-            await (0, project_graph_1.createProjectGraphAsync)();
-        }
-        catch (e) {
-            projectGraphError = e;
-        }
-    }
     const packageVersionsWeCareAbout = findInstalledPackagesWeCareAbout();
     packageVersionsWeCareAbout.unshift({
         package: 'nx',
@@ -130,9 +123,24 @@ async function getReportData() {
     };
 }
 exports.getReportData = getReportData;
-async function findLocalPlugins(nxJson) {
+async function tryGetProjectGraph() {
+    try {
+        return { graph: await (0, project_graph_1.createProjectGraphAsync)() };
+    }
+    catch (error) {
+        if (error instanceof error_types_1.ProjectGraphError) {
+            return {
+                graph: error.getPartialProjectGraph(),
+                error: error,
+            };
+        }
+        return {
+            error,
+        };
+    }
+}
+async function findLocalPlugins(projectGraph, nxJson) {
     try {
-        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
         const localPlugins = await (0, local_plugins_1.getLocalWorkspacePlugins)((0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph), nxJson);
         return Array.from(localPlugins.keys());
     }

package/src/project-graph/plugins/internal-api.d.ts

@@ -25,5 +25,5 @@ export declare const nxPluginCache: Map<unknown, [
     Promise<LoadedNxPlugin>,
     () => void
 ]>;
-export declare function loadNxPlugins(plugins: PluginConfiguration[], root?: string): Promise<[LoadedNxPlugin[], () => void]>;
+export declare function loadNxPlugins(plugins: PluginConfiguration[], root?: string): Promise<readonly [LoadedNxPlugin[], () => void]>;
 export declare function getDefaultPlugins(root: string): Promise<string[]>;

package/src/project-graph/plugins/internal-api.js

@@ -69,18 +69,19 @@ exports.LoadedNxPlugin = LoadedNxPlugin;
 // referenced multiple times.
 exports.nxPluginCache = new Map();
 async function loadNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
-    const result = [];
+    performance.mark('loadNxPlugins:start');
     const loadingMethod = process.env.NX_ISOLATE_PLUGINS === 'true'
         ? isolation_1.loadNxPluginInIsolation
         : loader_1.loadNxPlugin;
     plugins = await normalizePlugins(plugins, root);
+    const result = new Array(plugins?.length);
     const cleanupFunctions = [];
-    for (const plugin of plugins) {
+    await Promise.all(plugins.map(async (plugin, idx) => {
         const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
-        result.push(loadedPluginPromise);
+        result[idx] = loadedPluginPromise;
         cleanupFunctions.push(cleanup);
-    }
-    return [
+    }));
+    const ret = [
         await Promise.all(result),
         () => {
             for (const fn of cleanupFunctions) {
@@ -91,6 +92,9 @@ async function loadNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
             }
         },
     ];
+    performance.mark('loadNxPlugins:end');
+    performance.measure('loadNxPlugins', 'loadNxPlugins:start', 'loadNxPlugins:end');
+    return ret;
 }
 exports.loadNxPlugins = loadNxPlugins;
 async function normalizePlugins(plugins, root) {

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -84,7 +84,7 @@ export interface PluginCreateMetadataResult {
         tx: string;
     } | {
         success: false;
-        error: string;
+        error: Error;
         tx: string;
     };
 }

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const messaging_1 = require("./messaging");
 const loader_1 = require("../loader");
 const serializable_error_1 = require("../../../utils/serializable-error");
-const net_1 = require("net");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+const net_1 = require("net");
 const fs_1 = require("fs");
 if (process.env.NX_PERF_LOGGING === 'true') {
     require('../../../utils/perf-logging');
@@ -117,7 +117,11 @@ const server = (0, net_1.createServer)((socket) => {
                 catch (e) {
                     return {
                         type: 'createMetadataResult',
-                        payload: { success: false, error: e.stack, tx },
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
                     };
                 }
             },

package/src/project-graph/utils/project-configuration-utils.js

@@ -253,8 +253,10 @@ plugins) {
                 else {
                     errorBodyLines.push(`  - ${e.message}`);
                 }
+                const innerStackTrace = '    ' + e.stack.split('\n').join('\n    ');
+                errorBodyLines.push(innerStackTrace);
             }
-            error.message = errorBodyLines.join('\n');
+            error.stack = errorBodyLines.join('\n');
             // This represents a single plugin erroring out with a hard error.
             errors.push(error);
             // The plugin didn't return partial results, so we return an empty array.

package/src/tasks-runner/create-task-graph.d.ts

@@ -11,10 +11,11 @@ export declare class ProcessTasks {
     readonly dependencies: {
         [k: string]: string[];
     };
+    private readonly allTargetNames;
     constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph);
     processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Object, excludeTaskDependencies: boolean): string[];
     processTask(task: Task, projectUsedToDeriveDependencies: string, configuration: string, overrides: Object): void;
-    private processTasksForMatchingProjects;
+    private processTasksForMultipleProjects;
     private processTasksForSingleProject;
     private processTasksForDependencies;
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Object): Task;

package/src/tasks-runner/create-task-graph.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapTargetDefaultsToDependencies = exports.createTaskGraph = exports.ProcessTasks = void 0;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
-const find_matching_projects_1 = require("../utils/find-matching-projects");
 const output_1 = require("../utils/output");
 class ProcessTasks {
     constructor(extraTargetDependencies, projectGraph) {
@@ -12,6 +11,14 @@ class ProcessTasks {
         this.seen = new Set();
         this.tasks = {};
         this.dependencies = {};
+        const allTargetNames = new Set();
+        for (const projectName in projectGraph.nodes) {
+            const project = projectGraph.nodes[projectName];
+            for (const targetName in project.data.targets ?? {}) {
+                allTargetNames.add(targetName);
+            }
+        }
+        this.allTargetNames = Array.from(allTargetNames);
     }
     processTasks(projectNames, targets, configuration, overrides, excludeTaskDependencies) {
         for (const projectName of projectNames) {
@@ -58,32 +65,13 @@ class ProcessTasks {
             return;
         }
         this.seen.add(seenKey);
-        const dependencyConfigs = (0, utils_1.getDependencyConfigs)({ project: task.target.project, target: task.target.target }, this.extraTargetDependencies, this.projectGraph);
+        const dependencyConfigs = (0, utils_1.getDependencyConfigs)({ project: task.target.project, target: task.target.target }, this.extraTargetDependencies, this.projectGraph, this.allTargetNames);
         for (const dependencyConfig of dependencyConfigs) {
             const taskOverrides = dependencyConfig.params === 'forward'
                 ? overrides
                 : { __overrides_unparsed__: [] };
             if (dependencyConfig.projects) {
-                /** LERNA SUPPORT START - Remove in v20 */
-                // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
-                // support for it until lerna can be updated to use the syntax.
-                //
-                // This should have been removed in v17, but the updates to lerna had not
-                // been made yet.
-                //
-                // TODO(@agentender): Remove this part in v20
-                if (typeof dependencyConfig.projects === 'string') {
-                    if (dependencyConfig.projects === 'self') {
-                        this.processTasksForSingleProject(task, task.target.project, dependencyConfig, configuration, taskOverrides, overrides);
-                        continue;
-                    }
-                    else if (dependencyConfig.projects === 'dependencies') {
-                        this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
-                        continue;
-                    }
-                }
-                /** LERNA SUPPORT END - Remove in v17 */
-                this.processTasksForMatchingProjects(dependencyConfig, configuration, task, taskOverrides, overrides);
+                this.processTasksForMultipleProjects(dependencyConfig, configuration, task, taskOverrides, overrides);
             }
             else if (dependencyConfig.dependencies) {
                 this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
@@ -93,20 +81,16 @@ class ProcessTasks {
             }
         }
     }
-    processTasksForMatchingProjects(dependencyConfig, configuration, task, taskOverrides, overrides) {
-        const targetProjectSpecifiers = typeof dependencyConfig.projects === 'string'
-            ? [dependencyConfig.projects]
-            : dependencyConfig.projects;
-        const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(targetProjectSpecifiers, this.projectGraph.nodes);
-        if (matchingProjects.length === 0) {
+    processTasksForMultipleProjects(dependencyConfig, configuration, task, taskOverrides, overrides) {
+        if (dependencyConfig.projects.length === 0) {
             output_1.output.warn({
                 title: `\`dependsOn\` is misconfigured for ${task.target.project}:${task.target.target}`,
                 bodyLines: [
-                    `Project patterns "${targetProjectSpecifiers}" does not match any projects.`,
+                    `Project patterns "${dependencyConfig.projects}" does not match any projects.`,
                 ],
             });
         }
-        for (const projectName of matchingProjects) {
+        for (const projectName of dependencyConfig.projects) {
             this.processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides);
         }
     }

package/src/tasks-runner/task-orchestrator.js

@@ -264,6 +264,14 @@ class TaskOrchestrator {
                     });
                 }
             }
+            else if (targetConfiguration.executor === 'nx:noop') {
+                (0, fs_1.writeFileSync)(temporaryOutputPath, '');
+                results.push({
+                    task,
+                    status: 'success',
+                    terminalOutput: '',
+                });
+            }
             else {
                 // cache prep
                 const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);

package/src/tasks-runner/utils.d.ts

@@ -2,12 +2,25 @@ import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
 import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
+export type NormalizedTargetDependencyConfig = TargetDependencyConfig & {
+    projects: string[];
+};
 export declare function getDependencyConfigs({ project, target }: {
     project: string;
     target: string;
-}, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, projectGraph: ProjectGraph): TargetDependencyConfig[] | undefined;
-export declare function expandDependencyConfigSyntaxSugar(dependencyConfigString: string, graph: ProjectGraph): TargetDependencyConfig;
+}, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, projectGraph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[] | undefined;
+export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
+export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph): NormalizedTargetDependencyConfig;
+export declare function expandDependencyConfigSyntaxSugar(dependencyConfigString: string | TargetDependencyConfig, graph: ProjectGraph): TargetDependencyConfig;
+export declare function expandWildcardTargetConfiguration(dependencyConfig: NormalizedTargetDependencyConfig, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
+export declare function readProjectAndTargetFromTargetString(targetString: string, projects: Record<string, ProjectGraphProjectNode>): {
+    projects?: string[];
+    target: string;
+};
 export declare function getOutputs(p: Record<string, ProjectGraphProjectNode>, target: Task['target'], overrides: Task['overrides']): string[];
+export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig): Omit<TargetDependencyConfig, 'projects'> & {
+    projects: string[];
+};
 declare class InvalidOutputsError extends Error {
     outputs: string[];
     invalidOutputs: Set<string>;

package/src/tasks-runner/utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.getTargetConfigurationForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = void 0;
-const output_1 = require("../utils/output");
+exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.getTargetConfigurationForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.normalizeTargetDependencyWithStringProjects = exports.getOutputs = exports.readProjectAndTargetFromTargetString = exports.expandWildcardTargetConfiguration = exports.expandDependencyConfigSyntaxSugar = exports.normalizeDependencyConfigProjects = exports.normalizeDependencyConfigDefinition = exports.getDependencyConfigs = void 0;
 const path_1 = require("path");
 const posix_1 = require("path/posix");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -11,28 +10,35 @@ const serialize_overrides_into_command_line_1 = require("../utils/serialize-over
 const split_target_1 = require("../utils/split-target");
 const executor_utils_1 = require("../command-line/run/executor-utils");
 const project_graph_1 = require("../project-graph/project-graph");
-function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph) {
+const find_matching_projects_1 = require("../utils/find-matching-projects");
+const minimatch_1 = require("minimatch");
+function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph, allTargetNames) {
     const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
         // This is passed into `run-command` from programmatic invocations
         extraTargetDependencies[target] ??
-        []).map((config) => typeof config === 'string'
-        ? expandDependencyConfigSyntaxSugar(config, projectGraph)
-        : config);
-    for (const dependencyConfig of dependencyConfigs) {
-        if (dependencyConfig.projects && dependencyConfig.dependencies) {
-            output_1.output.error({
-                title: `dependsOn is improperly configured for ${project}:${target}`,
-                bodyLines: [
-                    `dependsOn.projects and dependsOn.dependencies cannot be used together.`,
-                ],
-            });
-            process.exit(1);
-        }
-    }
+        []).flatMap((config) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames));
     return dependencyConfigs;
 }
 exports.getDependencyConfigs = getDependencyConfigs;
+function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames) {
+    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph), currentProject, graph), allTargetNames);
+}
+exports.normalizeDependencyConfigDefinition = normalizeDependencyConfigDefinition;
+function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph) {
+    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig);
+    if (noStringConfig.projects) {
+        dependencyConfig.projects = (0, find_matching_projects_1.findMatchingProjects)(noStringConfig.projects, graph.nodes);
+    }
+    else if (!noStringConfig.dependencies) {
+        dependencyConfig.projects = [currentProject];
+    }
+    return dependencyConfig;
+}
+exports.normalizeDependencyConfigProjects = normalizeDependencyConfigProjects;
 function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph) {
+    if (typeof dependencyConfigString !== 'string') {
+        return dependencyConfigString;
+    }
     const [dependencies, targetString] = dependencyConfigString.startsWith('^')
         ? [true, dependencyConfigString.substring(1)]
         : [false, dependencyConfigString];
@@ -44,26 +50,84 @@ function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph) {
             dependencies: true,
         };
     }
+    const { projects, target } = readProjectAndTargetFromTargetString(targetString, graph.nodes);
+    return projects ? { projects, target } : { target };
+}
+exports.expandDependencyConfigSyntaxSugar = expandDependencyConfigSyntaxSugar;
+// Weakmap let's the cache get cleared by garbage collector if allTargetNames is no longer used
+const patternResultCache = new WeakMap();
+function expandWildcardTargetConfiguration(dependencyConfig, allTargetNames) {
+    if (!find_matching_projects_1.GLOB_CHARACTERS.some((char) => dependencyConfig.target.includes(char))) {
+        return [dependencyConfig];
+    }
+    let cache = patternResultCache.get(allTargetNames);
+    if (!cache) {
+        cache = new Map();
+        patternResultCache.set(allTargetNames, cache);
+    }
+    const cachedResult = cache.get(dependencyConfig.target);
+    if (cachedResult) {
+        return cachedResult;
+    }
+    const matcher = minimatch_1.minimatch.filter(dependencyConfig.target);
+    const matchingTargets = allTargetNames.filter((t) => matcher(t));
+    const result = matchingTargets.map((t) => ({
+        ...dependencyConfig,
+        target: t,
+    }));
+    cache.set(dependencyConfig.target, result);
+    return result;
+}
+exports.expandWildcardTargetConfiguration = expandWildcardTargetConfiguration;
+function readProjectAndTargetFromTargetString(targetString, projects) {
     // Support for both `project:target` and `target:with:colons` syntax
     const [maybeProject, ...segments] = (0, split_target_1.splitByColons)(targetString);
-    // if no additional segments are provided, then the string references
-    // a target of the same project
     if (!segments.length) {
+        // if no additional segments are provided, then the string references
+        // a target of the same project
         return { target: maybeProject };
     }
-    return {
+    else if (maybeProject in projects) {
         // Only the first segment could be a project. If it is, the rest is a target.
         // If its not, then the whole targetString was a target with colons in its name.
-        target: maybeProject in graph.nodes ? segments.join(':') : targetString,
+        return { projects: [maybeProject], target: segments.join(':') };
+    }
+    else {
         // If the first segment is a project, then we have a specific project. Otherwise, we don't.
-        projects: maybeProject in graph.nodes ? [maybeProject] : undefined,
-    };
+        return { target: targetString };
+    }
 }
-exports.expandDependencyConfigSyntaxSugar = expandDependencyConfigSyntaxSugar;
+exports.readProjectAndTargetFromTargetString = readProjectAndTargetFromTargetString;
 function getOutputs(p, target, overrides) {
     return getOutputsForTargetAndConfiguration(target, overrides, p[target.project]);
 }
 exports.getOutputs = getOutputs;
+function normalizeTargetDependencyWithStringProjects(dependencyConfig) {
+    if (typeof dependencyConfig.projects === 'string') {
+        /** LERNA SUPPORT START - Remove in v20 */
+        // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
+        // support for it until lerna can be updated to use the syntax.
+        //
+        // This should have been removed in v17, but the updates to lerna had not
+        // been made yet.
+        //
+        // TODO(@agentender): Remove this part in v20
+        if (dependencyConfig.projects === 'self') {
+            delete dependencyConfig.projects;
+        }
+        else if (dependencyConfig.projects === 'dependencies') {
+            dependencyConfig.dependencies = true;
+            delete dependencyConfig.projects;
+            return;
+            /** LERNA SUPPORT END - Remove in v20 */
+        }
+        else {
+            dependencyConfig.projects = [dependencyConfig.projects];
+        }
+    }
+    return dependencyConfig;
+}
+exports.normalizeTargetDependencyWithStringProjects = normalizeTargetDependencyWithStringProjects;
 class InvalidOutputsError extends Error {
     constructor(outputs, invalidOutputs) {
         super(InvalidOutputsError.createMessage(invalidOutputs));

package/src/utils/find-matching-projects.d.ts

@@ -1,4 +1,8 @@
 import type { ProjectGraphProjectNode } from '../config/project-graph';
+/**
+ * The presence of these characters in a string indicates that it might be a glob pattern.
+ */
+export declare const GLOB_CHARACTERS: string[];
 /**
  * Find matching project names given a list of potential project names or globs.
  *

package/src/utils/find-matching-projects.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMatchingStringsWithCache = exports.findMatchingProjects = void 0;
+exports.getMatchingStringsWithCache = exports.findMatchingProjects = exports.GLOB_CHARACTERS = void 0;
 const minimatch_1 = require("minimatch");
 const validPatternTypes = [
     'name', // Pattern is based on the project's name
@@ -8,7 +8,10 @@ const validPatternTypes = [
     'directory', // Pattern is based on the project's root directory
     'unlabeled', // Pattern was passed without specifying a type
 ];
-const globCharacters = ['*', '|', '{', '}', '(', ')'];
+/**
+ * The presence of these characters in a string indicates that it might be a glob pattern.
+ */
+exports.GLOB_CHARACTERS = ['*', '|', '{', '}', '(', ')'];
 /**
  * Find matching project names given a list of potential project names or globs.
  *
@@ -110,7 +113,7 @@ function addMatchingProjectsByName(projectNames, projects, pattern, matchedProje
         }
         return;
     }
-    if (!globCharacters.some((c) => pattern.value.includes(c))) {
+    if (!exports.GLOB_CHARACTERS.some((c) => pattern.value.includes(c))) {
         return;
     }
     const matchedProjectNames = (0, exports.getMatchingStringsWithCache)(pattern.value, projectNames);
@@ -135,7 +138,7 @@ function addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjec
             }
             continue;
         }
-        if (!globCharacters.some((c) => pattern.value.includes(c))) {
+        if (!exports.GLOB_CHARACTERS.some((c) => pattern.value.includes(c))) {
             continue;
         }
         if ((0, exports.getMatchingStringsWithCache)(pattern.value, tags).length) {

package/src/utils/serializable-error.js

@@ -17,6 +17,12 @@ function createSerializableError(error) {
             value = value.map((v) => {
                 if (typeof v === 'object' && v instanceof Error) {
                     return createSerializableError(v);
+                    // Support for AggregateCreateNodesError
+                }
+                else if (Array.isArray(v) &&
+                    v.length === 2 &&
+                    v[1] instanceof Error) {
+                    return [v[0], createSerializableError(v[1])];
                 }
                 return v;
             });