nx 19.6.4 → 19.6.5

package/src/command-line/release/utils/get-touched-projects-for-group.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetTouchedProjectsForGroup = createGetTouchedProjectsForGroup;
+const workspace_projects_1 = require("../../../project-graph/affected/locators/workspace-projects");
+const file_utils_1 = require("../../../project-graph/file-utils");
+const ignore_1 = require("../../../utils/ignore");
+const output_1 = require("../../../utils/output");
+const config_1 = require("../config/config");
+/**
+ * Create a function that returns the touched projects for a given release group. Only relevant when version plans are enabled.
+ */
+function createGetTouchedProjectsForGroup(nxArgs, projectGraph, changedFiles, fileData) {
+    /**
+     * Create a minimal subset of touched projects based on the configured ignore patterns, we only need
+     * to recompute when the ignorePatternsForPlanCheck differs between release groups.
+     */
+    const serializedIgnorePatternsToTouchedProjects = new Map();
+    return async function getTouchedProjectsForGroup(releaseGroup, 
+    // We don't access releaseGroups.projects directly, because we need to take the --projects filter into account
+    releaseGroupFilteredProjectNames, hasProjectsFilter) {
+        // The current release group doesn't leverage version plans
+        if (!releaseGroup.versionPlans) {
+            return [];
+        }
+        // Exclude patterns from .nxignore, .gitignore and explicit version plan config
+        let serializedIgnorePatterns = '[]';
+        const ignore = (0, ignore_1.getIgnoreObject)();
+        if (typeof releaseGroup.versionPlans !== 'boolean' &&
+            Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+            releaseGroup.versionPlans.ignorePatternsForPlanCheck.length) {
+            output_1.output.note({
+                title: `Applying configured ignore patterns to changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` for release group "${releaseGroup.name}"`
+                    : ''}`,
+                bodyLines: [
+                    ...releaseGroup.versionPlans.ignorePatternsForPlanCheck.map((pattern) => `  - ${pattern}`),
+                ],
+            });
+            ignore.add(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+            serializedIgnorePatterns = JSON.stringify(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+        }
+        let touchedProjects = {};
+        if (serializedIgnorePatternsToTouchedProjects.has(serializedIgnorePatterns)) {
+            touchedProjects = serializedIgnorePatternsToTouchedProjects.get(serializedIgnorePatterns);
+        }
+        else {
+            // We only care about directly touched projects, not implicitly affected ones etc
+            const touchedProjectsArr = await (0, workspace_projects_1.getTouchedProjects)((0, file_utils_1.calculateFileChanges)(changedFiles, fileData, nxArgs, undefined, ignore), projectGraph.nodes);
+            touchedProjects = touchedProjectsArr.reduce((acc, project) => ({ ...acc, [project]: true }), {});
+            serializedIgnorePatternsToTouchedProjects.set(serializedIgnorePatterns, touchedProjects);
+        }
+        const touchedProjectsUnderReleaseGroup = releaseGroupFilteredProjectNames.filter((project) => touchedProjects[project]);
+        if (touchedProjectsUnderReleaseGroup.length) {
+            output_1.output.log({
+                title: `Touched projects${hasProjectsFilter ? ` (after --projects filter applied)` : ''} based on changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` under release group "${releaseGroup.name}"`
+                    : ''}`,
+                bodyLines: [
+                    ...touchedProjectsUnderReleaseGroup.map((project) => `  - ${project}`),
+                    '',
+                    'NOTE: You can adjust your "versionPlans.ignorePatternsForPlanCheck" config to stop certain files from resulting in projects being classed as touched for the purposes of this command.',
+                ],
+            });
+        }
+        else {
+            output_1.output.log({
+                title: `No touched projects${hasProjectsFilter ? ` (after --projects filter applied)` : ''} found based on changed files${typeof releaseGroup.versionPlans !== 'boolean' &&
+                    Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+                    releaseGroup.versionPlans.ignorePatternsForPlanCheck.length
+                    ? ' combined with configured ignore patterns'
+                    : ''}${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` under release group "${releaseGroup.name}"`
+                    : ''}`,
+            });
+        }
+        return touchedProjectsUnderReleaseGroup;
+    };
+}

package/src/command-line/release/utils/git.d.ts

@@ -62,6 +62,6 @@ export declare function parseConventionalCommitsMessage(message: string): {
     description: string;
     breaking: boolean;
 } | null;
-export declare function parseGitCommit(commit: RawGitCommit): GitCommit | null;
+export declare function parseGitCommit(commit: RawGitCommit, isVersionPlanCommit?: boolean): GitCommit | null;
 export declare function getCommitHash(ref: string): Promise<string>;
 export declare function getFirstGitCommit(): Promise<string>;

package/src/command-line/release/utils/git.js

@@ -281,6 +281,30 @@ function parseConventionalCommitsMessage(message) {
         breaking: Boolean(match.groups.breaking),
     };
 }
+function extractReferencesFromCommitMessage(message, shortHash) {
+    const references = [];
+    for (const m of message.matchAll(PullRequestRE)) {
+        references.push({ type: 'pull-request', value: m[1] });
+    }
+    for (const m of message.matchAll(IssueRE)) {
+        if (!references.some((i) => i.value === m[1])) {
+            references.push({ type: 'issue', value: m[1] });
+        }
+    }
+    references.push({ value: shortHash, type: 'hash' });
+    return references;
+}
+function getAllAuthorsForCommit(commit) {
+    const authors = [commit.author];
+    // Additional authors can be specified in the commit body (depending on the VCS provider)
+    for (const match of commit.body.matchAll(CoAuthoredByRegex)) {
+        authors.push({
+            name: (match.groups.name || '').trim(),
+            email: (match.groups.email || '').trim(),
+        });
+    }
+    return authors;
+}
 // https://www.conventionalcommits.org/en/v1.0.0/
 // https://regex101.com/r/FSfNvA/1
 const ConventionalCommitRegex = /(?<type>[a-z]+)(\((?<scope>.+)\))?(?<breaking>!)?: (?<description>.+)/i;
@@ -289,7 +313,25 @@ const PullRequestRE = /\([ a-z]*(#\d+)\s*\)/gm;
 const IssueRE = /(#\d+)/gm;
 const ChangedFileRegex = /(A|M|D|R\d*|C\d*)\t([^\t\n]*)\t?(.*)?/gm;
 const RevertHashRE = /This reverts commit (?<hash>[\da-f]{40})./gm;
-function parseGitCommit(commit) {
+function parseGitCommit(commit, isVersionPlanCommit = false) {
+    // For version plans, we do not require conventional commits and therefore cannot extract data based on that format
+    if (isVersionPlanCommit) {
+        return {
+            ...commit,
+            description: commit.message,
+            type: '',
+            scope: '',
+            references: extractReferencesFromCommitMessage(commit.message, commit.shortHash),
+            // The commit message is not the source of truth for a breaking (major) change in version plans, so the value is not relevant
+            // TODO(v20): Make the current GitCommit interface more clearly tied to conventional commits
+            isBreaking: false,
+            authors: getAllAuthorsForCommit(commit),
+            // Not applicable to version plans
+            affectedFiles: [],
+            // Not applicable, a version plan cannot have been added in a commit that also reverts another commit
+            revertedHashes: [],
+        };
+    }
     const parsedMessage = parseConventionalCommitsMessage(commit.message);
     if (!parsedMessage) {
         return null;
@@ -298,16 +340,7 @@ function parseGitCommit(commit) {
     const isBreaking = parsedMessage.breaking || commit.body.includes('BREAKING CHANGE:');
     let description = parsedMessage.description;
     // Extract references from message
-    const references = [];
-    for (const m of description.matchAll(PullRequestRE)) {
-        references.push({ type: 'pull-request', value: m[1] });
-    }
-    for (const m of description.matchAll(IssueRE)) {
-        if (!references.some((i) => i.value === m[1])) {
-            references.push({ type: 'issue', value: m[1] });
-        }
-    }
-    references.push({ value: commit.shortHash, type: 'hash' });
+    const references = extractReferencesFromCommitMessage(description, commit.shortHash);
     // Remove references and normalize
     description = description.replace(PullRequestRE, '').trim();
     let type = parsedMessage.type;
@@ -322,13 +355,7 @@ function parseGitCommit(commit) {
         description = commit.message;
     }
     // Find all authors
-    const authors = [commit.author];
-    for (const match of commit.body.matchAll(CoAuthoredByRegex)) {
-        authors.push({
-            name: (match.groups.name || '').trim(),
-            email: (match.groups.email || '').trim(),
-        });
-    }
+    const authors = getAllAuthorsForCommit(commit);
     // Extract file changes from commit body
     const affectedFiles = Array.from(commit.body.matchAll(ChangedFileRegex)).reduce((prev, [fullLine, changeType, file1, file2]) => 
     // file2 only exists for some change types, such as renames

package/src/command-line/release/version.js

@@ -82,7 +82,7 @@ function createAPI(overrideReleaseConfig) {
         }
         if (!args.specifier) {
             const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-            (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+            await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes), args.verbose);
         }
         else {
             if (args.verbose && releaseGroups.some((g) => !!g.versionPlans)) {

package/src/daemon/server/sync-generators.d.ts

@@ -4,3 +4,7 @@ export declare function getCachedSyncGeneratorChanges(generators: string[]): Pro
 export declare function flushSyncGeneratorChangesToDisk(generators: string[]): Promise<void>;
 export declare function collectAndScheduleSyncGenerators(projectGraph: ProjectGraph): void;
 export declare function getCachedRegisteredSyncGenerators(): Promise<string[]>;
+/**
+ * @internal
+ */
+export declare function _getConflictingGeneratorGroups(results: SyncGeneratorChangesResult[]): string[][];

package/src/daemon/server/sync-generators.js

@@ -4,6 +4,7 @@ exports.getCachedSyncGeneratorChanges = getCachedSyncGeneratorChanges;
 exports.flushSyncGeneratorChangesToDisk = flushSyncGeneratorChangesToDisk;
 exports.collectAndScheduleSyncGenerators = collectAndScheduleSyncGenerators;
 exports.getCachedRegisteredSyncGenerators = getCachedRegisteredSyncGenerators;
+exports._getConflictingGeneratorGroups = _getConflictingGeneratorGroups;
 const nx_json_1 = require("../../config/nx-json");
 const tree_1 = require("../../generators/tree");
 const file_hasher_1 = require("../../hasher/file-hasher");
@@ -24,7 +25,6 @@ let storedNxJsonHash;
 const log = (...messageParts) => {
     logger_1.serverLogger.log('[SYNC]:', ...messageParts);
 };
-// TODO(leo): check conflicts and reuse the Tree where possible
 async function getCachedSyncGeneratorChanges(generators) {
     try {
         log('get sync generators changes on demand', generators);
@@ -36,51 +36,15 @@ async function getCachedSyncGeneratorChanges(generators) {
         }
         // reset the wait time
         waitPeriod = 100;
-        let projects;
-        let errored = false;
-        const getProjectsConfigurations = async () => {
-            if (projects || errored) {
-                return projects;
-            }
-            const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
-            projects = projectGraph
-                ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
-                : null;
-            errored = error !== undefined;
-            return projects;
-        };
-        return (await Promise.all(generators.map(async (generator) => {
-            if (scheduledGenerators.has(generator) ||
-                !syncGeneratorsCacheResultPromises.has(generator)) {
-                // it's scheduled to run (there are pending changes to process) or
-                // it's not scheduled and there's no cached result, so run it
-                const projects = await getProjectsConfigurations();
-                if (projects) {
-                    log(generator, 'already scheduled or not cached, running it now');
-                    runGenerator(generator, projects);
-                }
-                else {
-                    log(generator, 'already scheduled or not cached, project graph errored');
-                    /**
-                     * This should never happen. This is invoked imperatively, and by
-                     * the time it is invoked, the project graph would have already
-                     * been requested. If it errored, it would have been reported and
-                     * this wouldn't have been invoked. We handle it just in case.
-                     *
-                     * Since the project graph would be reported by the relevant
-                     * handlers separately, we just ignore the error, don't cache
-                     * any result and return an empty result, the next time this is
-                     * invoked the process will repeat until it eventually recovers
-                     * when the project graph is fixed.
-                     */
-                    return Promise.resolve({ changes: [], generatorName: generator });
-                }
-            }
-            else {
-                log(generator, 'not scheduled and has cached result, returning cached result');
-            }
-            return syncGeneratorsCacheResultPromises.get(generator);
-        }))).flat();
+        const results = await getFromCacheOrRunGenerators(generators);
+        const conflicts = _getConflictingGeneratorGroups(results);
+        if (!conflicts.length) {
+            // there are no conflicts
+            return results;
+        }
+        // there are conflicts, so we need to re-run the conflicting generators
+        // using the same tree
+        return await processConflictingGenerators(conflicts, results);
     }
     catch (e) {
         console.error(e);
@@ -126,7 +90,7 @@ function collectAndScheduleSyncGenerators(projectGraph) {
         }
         const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
         for (const generator of scheduledGenerators) {
-            runGenerator(generator, projects);
+            syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
         }
         await Promise.all(syncGeneratorsCacheResultPromises.values());
     }, waitPeriod);
@@ -143,6 +107,163 @@ async function getCachedRegisteredSyncGenerators() {
     }
     return [...registeredSyncGenerators];
 }
+async function getFromCacheOrRunGenerators(generators) {
+    let projects;
+    let errored = false;
+    const getProjectsConfigurations = async () => {
+        if (projects || errored) {
+            return projects;
+        }
+        const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        projects = projectGraph
+            ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+            : null;
+        errored = error !== undefined;
+        return projects;
+    };
+    return (await Promise.all(generators.map(async (generator) => {
+        if (scheduledGenerators.has(generator) ||
+            !syncGeneratorsCacheResultPromises.has(generator)) {
+            // it's scheduled to run (there are pending changes to process) or
+            // it's not scheduled and there's no cached result, so run it
+            const projects = await getProjectsConfigurations();
+            if (projects) {
+                log(generator, 'already scheduled or not cached, running it now');
+                syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
+            }
+            else {
+                log(generator, 'already scheduled or not cached, project graph errored');
+                /**
+                 * This should never happen. This is invoked imperatively, and by
+                 * the time it is invoked, the project graph would have already
+                 * been requested. If it errored, it would have been reported and
+                 * this wouldn't have been invoked. We handle it just in case.
+                 *
+                 * Since the project graph would be reported by the relevant
+                 * handlers separately, we just ignore the error, don't cache
+                 * any result and return an empty result, the next time this is
+                 * invoked the process will repeat until it eventually recovers
+                 * when the project graph is fixed.
+                 */
+                return Promise.resolve({ changes: [], generatorName: generator });
+            }
+        }
+        else {
+            log(generator, 'not scheduled and has cached result, returning cached result');
+        }
+        return syncGeneratorsCacheResultPromises.get(generator);
+    }))).flat();
+}
+async function runConflictingGenerators(tree, generators) {
+    const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const projects = projectGraph
+        ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+        : null;
+    if (!projects) {
+        /**
+         * This should never happen. This is invoked imperatively, and by
+         * the time it is invoked, the project graph would have already
+         * been requested. If it errored, it would have been reported and
+         * this wouldn't have been invoked. We handle it just in case.
+         *
+         * Since the project graph would be reported by the relevant
+         * handlers separately, we just ignore the error.
+         */
+        return generators.map((generator) => ({
+            changes: [],
+            generatorName: generator,
+        }));
+    }
+    // we need to run conflicting generators sequentially because they use the same tree
+    const results = [];
+    for (const generator of generators) {
+        log(generator, 'running it now');
+        results.push(await runGenerator(generator, projects, tree));
+    }
+    return results;
+}
+async function processConflictingGenerators(conflicts, initialResults) {
+    const conflictRunResults = (await Promise.all(conflicts.map((generators) => {
+        const [firstGenerator, ...generatorsToRun] = generators;
+        // it must exists because the conflicts were identified from the initial results
+        const firstGeneratorResult = initialResults.find((r) => r.generatorName === firstGenerator);
+        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generators ${generators.join(',')}`);
+        // pre-apply the changes from the first generator to avoid running it
+        for (const change of firstGeneratorResult.changes) {
+            if (change.type === 'CREATE' || change.type === 'UPDATE') {
+                tree.write(change.path, change.content, change.options);
+            }
+            else if (change.type === 'DELETE') {
+                tree.delete(change.path);
+            }
+        }
+        /**
+         * We don't cache the results of conflicting generators because they
+         * use the same tree, so some files might contain results from multiple
+         * generators and we don't have guarantees that the same combination of
+         * generators will run together.
+         */
+        return runConflictingGenerators(tree, generatorsToRun);
+    }))).flat();
+    /**
+     * The order of the results from the re-run generators is important because
+     * the last result from a group of conflicting generators will contain the
+     * changes from the previous conflicting generators. So, instead of replacing
+     * in-place the initial results, we first add the results from the re-run
+     * generators, and then add the initial results that were not from a
+     * conflicting generator.
+     */
+    const results = [...conflictRunResults];
+    for (const result of initialResults) {
+        if (conflictRunResults.every((r) => r.generatorName !== result.generatorName)) {
+            // this result is not from a conflicting generator, so we add it to the
+            // results
+            results.push(result);
+        }
+    }
+    return results;
+}
+/**
+ * @internal
+ */
+function _getConflictingGeneratorGroups(results) {
+    const changedFileToGeneratorMap = new Map();
+    for (const result of results) {
+        for (const change of result.changes) {
+            if (!changedFileToGeneratorMap.has(change.path)) {
+                changedFileToGeneratorMap.set(change.path, new Set());
+            }
+            changedFileToGeneratorMap.get(change.path).add(result.generatorName);
+        }
+    }
+    const conflicts = [];
+    for (const generatorSet of changedFileToGeneratorMap.values()) {
+        if (generatorSet.size === 1) {
+            // no conflicts
+            continue;
+        }
+        if (conflicts.length === 0) {
+            // there are no conflicts yet, so we just add the first group
+            conflicts.push(new Set(generatorSet));
+            continue;
+        }
+        // identify if any of the current generator sets intersect with any of the
+        // existing conflict groups
+        const generatorsArray = Array.from(generatorSet);
+        const existingConflictGroup = conflicts.find((group) => generatorsArray.some((generator) => group.has(generator)));
+        if (existingConflictGroup) {
+            // there's an intersecting group, so we merge the two
+            for (const generator of generatorsArray) {
+                existingConflictGroup.add(generator);
+            }
+        }
+        else {
+            // there's no intersecting group, so we create a new one
+            conflicts.push(new Set(generatorsArray));
+        }
+    }
+    return conflicts.map((group) => Array.from(group));
+}
 function collectAllRegisteredSyncGenerators(projectGraph) {
     const projectGraphHash = hashProjectGraph(projectGraph);
     if (storedProjectGraphHash !== projectGraphHash) {
@@ -183,16 +304,15 @@ function collectAllRegisteredSyncGenerators(projectGraph) {
         }
     }
 }
-function runGenerator(generator, projects) {
+function runGenerator(generator, projects, tree) {
     log('running scheduled generator', generator);
     // remove it from the scheduled set
     scheduledGenerators.delete(generator);
-    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
-    // run the generator and cache the result
-    syncGeneratorsCacheResultPromises.set(generator, (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
+    tree ??= new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
+    return (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
         log(generator, 'changes:', result.changes.map((c) => c.path).join(', '));
         return result;
-    }));
+    });
 }
 function hashProjectGraph(projectGraph) {
     const stringifiedProjects = Object.entries(projectGraph.nodes)

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

@@ -273,7 +273,7 @@ async function startPluginWorker() {
                     socket,
                 });
             }
-            else if (attempts > 1000) {
+            else if (attempts > 10000) {
                 // daemon fails to start, the process probably exited
                 // we print the logs and exit the client
                 reject('Failed to start plugin worker.');

package/src/utils/git-utils.d.ts

@@ -1,6 +1,6 @@
-import { ExecSyncOptions } from 'child_process';
-export declare function cloneFromUpstream(url: string, destination: string, { originName }?: {
+export declare function cloneFromUpstream(url: string, destination: string, { originName, depth }?: {
     originName: string;
+    depth?: number;
 }): Promise<GitRepository>;
 export declare class GitRepository {
     private directory;
@@ -8,12 +8,10 @@ export declare class GitRepository {
     constructor(directory: string);
     getGitRootPath(cwd: string): string;
     addFetchRemote(remoteName: string, branch: string): Promise<string>;
-    private execAsync;
     showStat(): Promise<string>;
     listBranches(): Promise<string[]>;
     getGitFiles(path: string): Promise<string[]>;
     reset(ref: string): Promise<string>;
-    squashLastTwoCommits(): Promise<string>;
     mergeUnrelatedHistories(ref: string, message: string): Promise<string>;
     fetch(remote: string, ref?: string): Promise<string>;
     checkout(branch: string, opts: {
@@ -25,14 +23,13 @@ export declare class GitRepository {
     commit(message: string): Promise<string>;
     amendCommit(): Promise<string>;
     deleteGitRemote(name: string): Promise<string>;
-    deleteBranch(branch: string): Promise<string>;
     addGitRemote(name: string, url: string): Promise<string>;
+    hasFilterRepoInstalled(): Promise<boolean>;
+    filterRepo(subdirectory: string): Promise<string>;
+    filterBranch(subdirectory: string, branchName: string): Promise<string>;
+    private execAsync;
+    private quotePath;
 }
-/**
- * This is used by the squash editor script to update the rebase file.
- */
-export declare function updateRebaseFile(contents: string): string;
-export declare function fetchGitRemote(name: string, branch: string, execOptions: ExecSyncOptions): string | Buffer;
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
  */