nx 19.7.0-beta.2 → 19.7.0-beta.4

package/src/utils/git-utils.js

@@ -2,16 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitRepository = void 0;
 exports.cloneFromUpstream = cloneFromUpstream;
-exports.updateRebaseFile = updateRebaseFile;
-exports.fetchGitRemote = fetchGitRemote;
 exports.getGithubSlugOrNull = getGithubSlugOrNull;
 exports.extractUserAndRepoFromGitHubUrl = extractUserAndRepoFromGitHubUrl;
 exports.commitChanges = commitChanges;
 exports.getLatestCommitSha = getLatestCommitSha;
 const child_process_1 = require("child_process");
-const devkit_exports_1 = require("../devkit-exports");
 const path_1 = require("path");
-const SQUASH_EDITOR = (0, path_1.join)(__dirname, 'squash.js');
+const devkit_exports_1 = require("../devkit-exports");
 function execAsync(command, execOptions) {
     return new Promise((res, rej) => {
         (0, child_process_1.exec)(command, execOptions, (err, stdout, stderr) => {
@@ -22,9 +19,12 @@ function execAsync(command, execOptions) {
         });
     });
 }
-async function cloneFromUpstream(url, destination, { originName } = { originName: 'origin' }) {
-    await execAsync(`git clone ${url} ${destination} --depth 1 --origin ${originName}`, {
+async function cloneFromUpstream(url, destination, { originName, depth } = {
+    originName: 'origin',
+}) {
+    await execAsync(`git clone ${url} ${destination} ${depth ? `--depth ${depth}` : ''} --origin ${originName}`, {
         cwd: (0, path_1.dirname)(destination),
+        maxBuffer: 10 * 1024 * 1024,
     });
     return new GitRepository(destination);
 }
@@ -40,13 +40,8 @@ class GitRepository {
             .toString()
             .trim();
     }
-    addFetchRemote(remoteName, branch) {
-        return this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
-    }
-    execAsync(command) {
-        return execAsync(command, {
-            cwd: this.root,
-        });
+    async addFetchRemote(remoteName, branch) {
+        return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
     }
     async showStat() {
         return await this.execAsync(`git show --stat`);
@@ -61,62 +56,84 @@ class GitRepository {
             .replace('refs/heads/', ''));
     }
     async getGitFiles(path) {
-        return (await this.execAsync(`git ls-files ${path}`))
+        // Use -z to return file names exactly as they are stored in git, separated by NULL (\x00) character.
+        // This avoids problems with special characters in file names.
+        return (await this.execAsync(`git ls-files -z ${path}`))
             .trim()
-            .split('\n')
+            .split('\x00')
             .map((s) => s.trim())
             .filter(Boolean);
     }
     async reset(ref) {
-        return this.execAsync(`git reset ${ref} --hard`);
-    }
-    async squashLastTwoCommits() {
-        return this.execAsync(`git -c core.editor="node ${SQUASH_EDITOR}" rebase --interactive --no-autosquash HEAD~2`);
+        return await this.execAsync(`git reset ${ref} --hard`);
     }
     async mergeUnrelatedHistories(ref, message) {
-        return this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+        return await this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
     }
     async fetch(remote, ref) {
-        return this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+        return await this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
     }
     async checkout(branch, opts) {
-        return this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+        return await this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
     }
     async move(path, destination) {
-        return this.execAsync(`git mv "${path}" "${destination}"`);
+        return await this.execAsync(`git mv ${this.quotePath(path)} ${this.quotePath(destination)}`);
     }
     async push(ref, remoteName) {
-        return this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+        return await this.execAsync(`git push -u -f ${remoteName} ${ref}`);
     }
     async commit(message) {
-        return this.execAsync(`git commit -am "${message}"`);
+        return await this.execAsync(`git commit -am "${message}"`);
     }
     async amendCommit() {
-        return this.execAsync(`git commit --amend -a --no-edit`);
+        return await this.execAsync(`git commit --amend -a --no-edit`);
     }
-    deleteGitRemote(name) {
-        return this.execAsync(`git remote rm ${name}`);
+    async deleteGitRemote(name) {
+        return await this.execAsync(`git remote rm ${name}`);
     }
-    deleteBranch(branch) {
-        return this.execAsync(`git branch -D ${branch}`);
+    async addGitRemote(name, url) {
+        return await this.execAsync(`git remote add ${name} ${url}`);
+    }
+    async hasFilterRepoInstalled() {
+        try {
+            await this.execAsync(`git filter-repo --help`);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    addGitRemote(name, url) {
-        return this.execAsync(`git remote add ${name} ${url}`);
+    // git-filter-repo is much faster than filter-branch, but needs to be installed by user
+    // Use `hasFilterRepoInstalled` to check if it's installed
+    async filterRepo(subdirectory) {
+        // filter-repo requires POSIX path to work
+        const posixPath = subdirectory.split(path_1.sep).join(path_1.posix.sep);
+        return await this.execAsync(`git filter-repo -f --subdirectory-filter ${this.quotePath(posixPath)}`);
+    }
+    async filterBranch(subdirectory, branchName) {
+        // filter-repo requires POSIX path to work
+        const posixPath = subdirectory.split(path_1.sep).join(path_1.posix.sep);
+        // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
+        await this.execAsync(`git config core.quotepath false`);
+        return await this.execAsync(`git filter-branch --subdirectory-filter ${this.quotePath(posixPath)} -- ${branchName}`);
+    }
+    execAsync(command) {
+        return execAsync(command, {
+            cwd: this.root,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    quotePath(path) {
+        return process.platform === 'win32'
+            ? // Windows/CMD only understands double-quotes, single-quotes are treated as part of the file name
+                // Bash and other shells will substitute `$` in file names with a variable value.
+                `"${path}"`
+            : // e.g. `git mv "$$file.txt" "libs/a/$$file.txt"` will not work since `$$` is swapped with the PID of the last process.
+                // Using single-quotes prevents this substitution.
+                `'${path}'`;
     }
 }
 exports.GitRepository = GitRepository;
-/**
- * This is used by the squash editor script to update the rebase file.
- */
-function updateRebaseFile(contents) {
-    const lines = contents.split('\n');
-    const lastCommitIndex = lines.findIndex((line) => line === '') - 1;
-    lines[lastCommitIndex] = lines[lastCommitIndex].replace('pick', 'fixup');
-    return lines.join('\n');
-}
-function fetchGitRemote(name, branch, execOptions) {
-    return (0, child_process_1.execSync)(`git fetch ${name} ${branch} --depth 1`, execOptions);
-}
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
  */

package/src/utils/sync-generators.d.ts

@@ -1,7 +1,9 @@
 import type { GeneratorCallback } from '../config/misc-interfaces';
+import { type NxJsonConfiguration } from '../config/nx-json';
 import type { ProjectGraph } from '../config/project-graph';
+import type { TaskGraph } from '../config/task-graph';
 import type { ProjectConfiguration } from '../config/workspace-json-project-json';
-import { FsTree, type FileChange, type Tree } from '../generators/tree';
+import { type FileChange, type Tree } from '../generators/tree';
 export type SyncGeneratorResult = void | {
     callback?: GeneratorCallback;
     outOfSyncMessage?: string;
@@ -15,8 +17,9 @@ export type SyncGeneratorChangesResult = {
 };
 export declare function getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
 export declare function flushSyncGeneratorChanges(results: SyncGeneratorChangesResult[]): Promise<void>;
-export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph): Promise<string[]>;
-export declare function runSyncGenerator(tree: FsTree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorChangesResult>;
-export declare function collectRegisteredTaskSyncGenerators(projectGraph: ProjectGraph): Set<string>;
-export declare function collectRegisteredGlobalSyncGenerators(nxJson?: import("../config/nx-json").NxJsonConfiguration<string[] | "*">): Set<string>;
+export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Promise<string[]>;
+export declare function runSyncGenerator(tree: Tree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorChangesResult>;
+export declare function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
+export declare function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph: TaskGraph, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
+export declare function collectRegisteredGlobalSyncGenerators(nxJson?: NxJsonConfiguration<string[] | "*">): Set<string>;
 export declare function syncGeneratorResultsToMessageLines(results: SyncGeneratorChangesResult[]): string[];

package/src/utils/sync-generators.js

@@ -4,7 +4,8 @@ exports.getSyncGeneratorChanges = getSyncGeneratorChanges;
 exports.flushSyncGeneratorChanges = flushSyncGeneratorChanges;
 exports.collectAllRegisteredSyncGenerators = collectAllRegisteredSyncGenerators;
 exports.runSyncGenerator = runSyncGenerator;
-exports.collectRegisteredTaskSyncGenerators = collectRegisteredTaskSyncGenerators;
+exports.collectEnabledTaskSyncGeneratorsFromProjectGraph = collectEnabledTaskSyncGeneratorsFromProjectGraph;
+exports.collectEnabledTaskSyncGeneratorsFromTaskGraph = collectEnabledTaskSyncGeneratorsFromTaskGraph;
 exports.collectRegisteredGlobalSyncGenerators = collectRegisteredGlobalSyncGenerators;
 exports.syncGeneratorResultsToMessageLines = syncGeneratorResultsToMessageLines;
 const perf_hooks_1 = require("perf_hooks");
@@ -39,10 +40,10 @@ async function flushSyncGeneratorChanges(results) {
         await client_1.daemonClient.flushSyncGeneratorChangesToDisk(results.map((r) => r.generatorName));
     }
 }
-async function collectAllRegisteredSyncGenerators(projectGraph) {
+async function collectAllRegisteredSyncGenerators(projectGraph, nxJson) {
     if (!client_1.daemonClient.enabled()) {
         return [
-            ...collectRegisteredTaskSyncGenerators(projectGraph),
+            ...collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph, nxJson),
             ...collectRegisteredGlobalSyncGenerators(),
         ];
     }
@@ -69,17 +70,38 @@ async function runSyncGenerator(tree, generatorSpecifier, projects) {
         outOfSyncMessage,
     };
 }
-function collectRegisteredTaskSyncGenerators(projectGraph) {
+function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph, nxJson) {
     const taskSyncGenerators = new Set();
+    const disabledTaskSyncGenerators = new Set(nxJson.sync?.disabledTaskSyncGenerators ?? []);
     for (const { data: { targets }, } of Object.values(projectGraph.nodes)) {
         if (!targets) {
             continue;
         }
         for (const target of Object.values(targets)) {
-            if (!target.syncGenerators) {
+            if (!target.syncGenerators?.length) {
                 continue;
             }
             for (const generator of target.syncGenerators) {
+                if (!disabledTaskSyncGenerators.has(generator) &&
+                    !taskSyncGenerators.has(generator)) {
+                    taskSyncGenerators.add(generator);
+                }
+            }
+        }
+    }
+    return taskSyncGenerators;
+}
+function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph, projectGraph, nxJson) {
+    const taskSyncGenerators = new Set();
+    const disabledTaskSyncGenerators = new Set(nxJson.sync?.disabledTaskSyncGenerators ?? []);
+    for (const { target } of Object.values(taskGraph.tasks)) {
+        const { syncGenerators } = projectGraph.nodes[target.project].data.targets[target.target];
+        if (!syncGenerators?.length) {
+            continue;
+        }
+        for (const generator of syncGenerators) {
+            if (!disabledTaskSyncGenerators.has(generator) &&
+                !taskSyncGenerators.has(generator)) {
                 taskSyncGenerators.add(generator);
             }
         }

package/src/utils/squash.d.ts

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

package/src/utils/squash.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const git_utils_1 = require("./git-utils");
-// This script is used as an editor for git rebase -i
-// This is the file which git creates. When this script exits, the updates should be written to this file.
-const filePath = process.argv[2];
-// Change the second commit from pick to fixup
-const contents = (0, fs_1.readFileSync)(filePath).toString();
-const newContents = (0, git_utils_1.updateRebaseFile)(contents);
-// Write the updated contents back to the file
-(0, fs_1.writeFileSync)(filePath, newContents);