nx 19.2.2 → 19.3.0-canary.20240606-bccb2c5

package/src/daemon/client/client.js

@@ -19,6 +19,7 @@ const nx_json_1 = require("../../config/nx-json");
 const daemon_socket_messenger_1 = require("./daemon-socket-messenger");
 const cache_1 = require("../cache");
 const error_types_1 = require("../../project-graph/error-types");
+const dotenv_1 = require("../../utils/dotenv");
 const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
 const get_context_file_data_1 = require("../message-types/get-context-file-data");
 const get_files_in_directory_1 = require("../message-types/get-files-in-directory");
@@ -40,6 +41,7 @@ class DaemonClient {
         this._daemonReady = null;
         this._out = null;
         this._err = null;
+        (0, dotenv_1.loadRootEnvFiles)(workspace_root_1.workspaceRoot);
         try {
             this.nxJson = (0, configuration_1.readNxJson)();
         }

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -42,7 +42,7 @@ export interface NormalizedRunCommandsOptions extends RunCommandsOptions {
         [k: string]: any;
     };
     unparsedCommandArgs?: {
-        [k: string]: string | string[];
+        [k: string]: string;
     };
     args?: string;
 }

package/src/executors/run-commands/run-commands.impl.js

@@ -29,9 +29,7 @@ const propKeys = [
     'command',
     'commands',
     'color',
-    'no-color',
     'parallel',
-    'no-parallel',
     'readyWhen',
     'cwd',
     'args',
@@ -133,7 +131,6 @@ function normalizeOptions(options) {
             'parse-numbers': false,
             'parse-positional-numbers': false,
             'dot-notation': false,
-            'camel-case-expansion': false,
         },
     });
     options.unknownOptions = Object.keys(options)
@@ -297,21 +294,20 @@ function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
     else if (forwardAllArgs) {
         let args = '';
         if (Object.keys(opts.unknownOptions ?? {}).length > 0) {
-            const unknownOptionsArgs = Object.keys(opts.unknownOptions)
-                .filter((k) => typeof opts.unknownOptions[k] !== 'object' &&
-                opts.parsedArgs[k] === opts.unknownOptions[k])
-                .map((k) => `--${k}=${opts.unknownOptions[k]}`)
-                .map(wrapArgIntoQuotesIfNeeded)
-                .join(' ');
-            if (unknownOptionsArgs) {
-                args += ` ${unknownOptionsArgs}`;
-            }
+            args +=
+                ' ' +
+                    Object.keys(opts.unknownOptions)
+                        .filter((k) => typeof opts.unknownOptions[k] !== 'object' &&
+                        opts.parsedArgs[k] === opts.unknownOptions[k])
+                        .map((k) => `--${k}=${opts.unknownOptions[k]}`)
+                        .map(wrapArgIntoQuotesIfNeeded)
+                        .join(' ');
         }
         if (opts.args) {
             args += ` ${opts.args}`;
         }
         if (opts.__unparsed__?.length > 0) {
-            const filterdParsedOptions = filterPropKeysFromUnParsedOptions(opts.__unparsed__, opts.parsedArgs);
+            const filterdParsedOptions = filterPropKeysFromUnParsedOptions(opts.__unparsed__, opts.unparsedCommandArgs);
             if (filterdParsedOptions.length > 0) {
                 args += ` ${filterdParsedOptions
                     .map(wrapArgIntoQuotesIfNeeded)
@@ -339,14 +335,13 @@ function parseArgs(unparsedCommandArgs, unknownOptions, args) {
  * @param unparsedCommandArgs e.g. { prop1: 'value1', prop2: 'value2', args: 'test'}
  * @returns filtered options that are not part of the propKeys array e.g. ['--prop1', 'value1', '--prop2=value2']
  */
-function filterPropKeysFromUnParsedOptions(__unparsed__, parseArgs = {}) {
+function filterPropKeysFromUnParsedOptions(__unparsed__, unparsedCommandArgs = {}) {
     const parsedOptions = [];
     for (let index = 0; index < __unparsed__.length; index++) {
         const element = __unparsed__[index];
         if (element.startsWith('--')) {
             const key = element.replace('--', '');
             if (element.includes('=')) {
-                // key can be in the format of --key=value or --key.subkey=value (e.g. env.foo=bar)
                 if (!propKeys.includes(key.split('=')[0].split('.')[0])) {
                     // check if the key is part of the propKeys array
                     parsedOptions.push(element);
@@ -356,8 +351,7 @@ function filterPropKeysFromUnParsedOptions(__unparsed__, parseArgs = {}) {
                 // check if the next element is a value for the key
                 if (propKeys.includes(key)) {
                     if (index + 1 < __unparsed__.length &&
-                        parseArgs[key] &&
-                        __unparsed__[index + 1].toString() === parseArgs[key].toString()) {
+                        __unparsed__[index + 1] === unparsedCommandArgs[key]) {
                         index++; // skip the next element
                     }
                 }

package/src/hasher/file-hasher.js

@@ -10,7 +10,7 @@ exports.hashArray = hashArray;
 function hashObject(obj) {
     const { hashArray } = require('../native');
     const parts = [];
-    for (const key of Object.keys(obj ?? {}).sort()) {
+    for (const key of Object.keys(obj).sort()) {
         parts.push(key);
         parts.push(JSON.stringify(obj[key]));
     }

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TargetProjectLocator = exports.isBuiltinModuleImport = void 0;
 const node_module_1 = require("node:module");
 const node_path_1 = require("node:path");
-const semver_1 = require("semver");
 const find_project_for_path_1 = require("../../../../project-graph/utils/find-project-for-path");
 const fileutils_1 = require("../../../../utils/fileutils");
 const workspace_root_1 = require("../../../../utils/workspace-root");
@@ -139,8 +138,7 @@ class TargetProjectLocator {
                 this.npmResolutionCache.set(npmImportForProject, externalNodeName);
                 return externalNodeName;
             }
-            const version = (0, semver_1.clean)(externalPackageJson.version);
-            const npmProjectKey = `npm:${externalPackageJson.name}@${version}`;
+            const npmProjectKey = `npm:${externalPackageJson.name}@${externalPackageJson.version}`;
             const matchingExternalNode = this.npmProjects[npmProjectKey];
             if (!matchingExternalNode) {
                 return null;

package/src/plugins/package-json-workspaces/create-nodes.js

@@ -38,16 +38,7 @@ function buildPackageJsonWorkspacesMatcher(workspaceRoot, readJson) {
         positivePatterns.push('**/package.json');
     }
     return (p) => positivePatterns.some((positive) => (0, minimatch_1.minimatch)(p, positive)) &&
-        /**
-         * minimatch will return true if the given p is NOT excluded by the negative pattern.
-         *
-         * For example if the negative pattern is "!packages/vite", then the given p "packages/vite" will return false,
-         * the given p "packages/something-else/package.json" will return true.
-         *
-         * Therefore, we need to ensure that every negative pattern returns true to validate that the given p is not
-         * excluded by any of the negative patterns.
-         */
-        negativePatterns.every((negative) => (0, minimatch_1.minimatch)(p, negative));
+        !negativePatterns.some((negative) => (0, minimatch_1.minimatch)(p, negative));
 }
 exports.buildPackageJsonWorkspacesMatcher = buildPackageJsonWorkspacesMatcher;
 function createNodeFromPackageJson(pkgJsonPath, root) {

package/src/project-graph/error-types.js

@@ -161,16 +161,6 @@ class AggregateCreateNodesError extends Error {
         this.errors = errors;
         this.partialResults = partialResults;
         this.name = this.constructor.name;
-        if (
-        // Errors should be an array
-        !Array.isArray(errors) ||
-            !errors.every(
-            // Where every element is a tuple
-            (errorTuple) => Array.isArray(errorTuple) &&
-                // That has a length of 2
-                errorTuple.length === 2)) {
-            throw new Error('AggregateCreateNodesError must be constructed with an array of tuples where the first element is a filename or undefined and the second element is the underlying error.');
-        }
     }
 }
 exports.AggregateCreateNodesError = AggregateCreateNodesError;

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

@@ -45,7 +45,7 @@ class LoadedNxPlugin {
                         throw e;
                     }
                     // The underlying plugin errored out. We can't know any partial results.
-                    throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
+                    throw new error_types_1.AggregateCreateNodesError([null, e], []);
                 }
                 finally {
                     performance.mark(`${plugin.name}:createNodes - end`);

package/src/project-graph/utils/normalize-project-nodes.js

@@ -76,29 +76,11 @@ function normalizeImplicitDependencies(source, implicitDependencies, projects) {
     if (!implicitDependencies?.length) {
         return implicitDependencies ?? [];
     }
-    // Implicit dependencies handle negatives in a different
-    // way from most other `projects` fields. This is because
-    // they are used for multiple purposes.
-    const positivePatterns = [];
-    const negativePatterns = [];
-    for (const dep of implicitDependencies) {
-        if (dep.startsWith('!')) {
-            negativePatterns.push(dep);
-        }
-        else {
-            positivePatterns.push(dep);
-        }
-    }
-    // Finds all projects that match a positive pattern and are not excluded by a negative pattern
-    const deps = positivePatterns.length
-        ? (0, find_matching_projects_1.findMatchingProjects)(positivePatterns.concat(negativePatterns), projects).filter((x) => x !== source)
-        : [];
-    // Expands negative patterns to equal project names
-    const alwaysIgnoredDeps = (0, find_matching_projects_1.findMatchingProjects)(negativePatterns.map((x) => x.slice(1)), projects);
-    // We return the matching deps, but keep the negative patterns in the list
-    // so that they can be processed later by implicit-project-dependencies.ts
-    // This is what allows using a negative implicit dep to remove a dependency
-    // detected by createDependencies.
-    return deps.concat(alwaysIgnoredDeps.map((x) => '!' + x));
+    const matches = (0, find_matching_projects_1.findMatchingProjects)(implicitDependencies, projects);
+    return (matches
+        .filter((x) => x !== source)
+        // implicit dependencies that start with ! should hang around, to be processed by
+        // implicit-project-dependencies.ts after explicit deps are added to graph.
+        .concat(implicitDependencies.filter((x) => x.startsWith('!'))));
 }
 exports.normalizeImplicitDependencies = normalizeImplicitDependencies;

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

@@ -245,15 +245,7 @@ plugins) {
                     e
                 : // This represents a single plugin erroring out with a hard error.
                     new error_types_1.AggregateCreateNodesError([[null, e]], []);
-            const innerErrors = error.errors;
-            for (const [file, e] of innerErrors) {
-                if (file) {
-                    errorBodyLines.push(`  - ${file}: ${e.message}`);
-                }
-                else {
-                    errorBodyLines.push(`  - ${e.message}`);
-                }
-            }
+            errorBodyLines.push(...error.errors.map(([file, e]) => `  - ${file}: ${e.message}`));
             error.message = errorBodyLines.join('\n');
             // This represents a single plugin erroring out with a hard error.
             errors.push(error);

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -9,12 +9,12 @@ import { LoadedNxPlugin } from '../plugins/internal-api';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("nx/src/native").FileData[];
+        nonProjectFiles: import("../../native").FileData[];
     };
-    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.

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

@@ -64,26 +64,7 @@ class ProcessTasks {
                 ? 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.processTasksForMatchingProjects(dependencyConfig, projectUsedToDeriveDependencies, configuration, task, taskOverrides, overrides);
             }
             else if (dependencyConfig.dependencies) {
                 this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
@@ -93,21 +74,41 @@ class ProcessTasks {
             }
         }
     }
-    processTasksForMatchingProjects(dependencyConfig, configuration, task, taskOverrides, overrides) {
+    processTasksForMatchingProjects(dependencyConfig, projectUsedToDeriveDependencies, 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) {
-            output_1.output.warn({
-                title: `\`dependsOn\` is misconfigured for ${task.target.project}:${task.target.target}`,
-                bodyLines: [
-                    `Project patterns "${targetProjectSpecifiers}" does not match any projects.`,
-                ],
-            });
-        }
-        for (const projectName of matchingProjects) {
-            this.processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides);
+        for (const projectSpecifier of targetProjectSpecifiers) {
+            // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
+            // support for it until lerna can be updated to use the syntax.
+            // TODO(@agentender): Remove this part in v17
+            if (projectSpecifier === 'dependencies' &&
+                !this.projectGraph.nodes[projectSpecifier]) {
+                this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
+            }
+            else {
+                // Since we need to maintain support for dependencies, it is more coherent
+                // that we also support self.
+                // TODO(@agentender): Remove this part in v17
+                const matchingProjects = 
+                /** LERNA SUPPORT START - Remove in v17 */
+                projectSpecifier === 'self' &&
+                    !this.projectGraph.nodes[projectSpecifier]
+                    ? [task.target.project]
+                    : /** LERNA SUPPORT END */
+                        (0, find_matching_projects_1.findMatchingProjects)([projectSpecifier], this.projectGraph.nodes);
+                if (matchingProjects.length === 0) {
+                    output_1.output.warn({
+                        title: `\`dependsOn\` is misconfigured for ${task.target.project}:${task.target.target}`,
+                        bodyLines: [
+                            `Project pattern "${projectSpecifier}" does not match any projects.`,
+                        ],
+                    });
+                }
+                for (const projectName of matchingProjects) {
+                    this.processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides);
+                }
+            }
         }
     }
     processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides) {

package/src/utils/ab-testing.d.ts

@@ -31,7 +31,7 @@ declare const messageOptions: {
     }];
 };
 export type MessageKey = keyof typeof messageOptions;
-export type MessageData = (typeof messageOptions)[MessageKey][number];
+export type MessageData = typeof messageOptions[MessageKey][number];
 export declare class PromptMessages {
     private selectedMessages;
     getPrompt(key: MessageKey): MessageData;

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

@@ -22,15 +22,6 @@ function findMatchingProjects(patterns = [], projects) {
     }
     const projectNames = Object.keys(projects);
     const matchedProjects = new Set();
-    // If the first pattern is an exclude pattern,
-    // we add a wildcard pattern at the first to select
-    // all projects, except the ones that match the exclude pattern.
-    // e.g. ['!tag:someTag', 'project2'] will match all projects except
-    // the ones with the tag 'someTag', and also match the project 'project2',
-    // regardless of its tags.
-    if (isExcludePattern(patterns[0])) {
-        patterns.unshift('*');
-    }
     for (const stringPattern of patterns) {
         if (!stringPattern.length) {
             continue;
@@ -148,11 +139,8 @@ function addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjec
         }
     }
 }
-function isExcludePattern(pattern) {
-    return pattern.startsWith('!');
-}
 function parseStringPattern(pattern, projects) {
-    const isExclude = isExcludePattern(pattern);
+    const isExclude = pattern.startsWith('!');
     // Support for things like: `!{type}:value`
     if (isExclude) {
         pattern = pattern.substring(1);