nx 19.6.0-beta.2 → 19.6.0-beta.4

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

@@ -84,7 +84,7 @@ function createAPI(overrideReleaseConfig) {
             process.exit(1);
         }
         const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-        (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
         if (args.deleteVersionPlans === undefined) {
             // default to not delete version plans after versioning as they may be needed for changelog generation
             args.deleteVersionPlans = false;

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

@@ -29,7 +29,7 @@ export declare function withTargetAndConfigurationOption(yargs: Argv, demandOpti
 export declare function withConfiguration(yargs: Argv): Argv<{
     configuration: string;
 }>;
-export declare function withVerbose(yargs: Argv): Argv<{
+export declare function withVerbose<T>(yargs: Argv<T>): Argv<T & {
     verbose: boolean;
 }>;
 export declare function withBatch(yargs: Argv): any;

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

@@ -145,6 +145,13 @@ export interface NxReleaseConventionalCommitsConfiguration {
         } | boolean;
     } | boolean>;
 }
+export interface NxReleaseVersionPlansConfiguration {
+    /**
+     * Changes to files matching any of these optional patterns will be excluded from the affected project logic within the `nx release plan:check`
+     * command. This is useful for ignoring files that are not relevant to the versioning process, such as documentation or configuration files.
+     */
+    ignorePatternsForPlanCheck?: string[];
+}
 export interface NxReleaseConfiguration {
     /**
      * Shorthand for amending the projects which will be included in the implicit default release group (all projects by default).
@@ -193,7 +200,7 @@ export interface NxReleaseConfiguration {
          * Enables using version plans as a specifier source for versioning and
          * to determine changes for changelog generation.
          */
-        versionPlans?: boolean;
+        versionPlans?: NxReleaseVersionPlansConfiguration | boolean;
     }>;
     /**
      * Configures the default value for all groups that don't explicitly state their own projectsRelationship.
@@ -264,7 +271,7 @@ export interface NxReleaseConfiguration {
      * Enables using version plans as a specifier source for versioning and
      * to determine changes for changelog generation.
      */
-    versionPlans?: boolean;
+    versionPlans?: NxReleaseVersionPlansConfiguration | boolean;
 }
 export interface NxSyncConfiguration {
     /**

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

@@ -32,6 +32,7 @@ export interface NxArgs {
     excludeTaskDependencies?: boolean;
 }
 export declare function createOverrides(__overrides_unparsed__?: string[]): Record<string, any>;
+export declare function getBaseRef(nxJson: NxJsonConfiguration): string;
 export declare function splitArgsIntoNxArgsAndOverrides(args: {
     [k: string]: any;
 }, mode: 'run-one' | 'run-many' | 'affected' | 'print-affected', options: {

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOverrides = createOverrides;
+exports.getBaseRef = getBaseRef;
 exports.splitArgsIntoNxArgsAndOverrides = splitArgsIntoNxArgsAndOverrides;
 exports.readParallelFromArgsAndEnv = readParallelFromArgsAndEnv;
 exports.parseFiles = parseFiles;
@@ -24,6 +25,9 @@ function createOverrides(__overrides_unparsed__ = []) {
     overrides.__overrides_unparsed__ = __overrides_unparsed__;
     return overrides;
 }
+function getBaseRef(nxJson) {
+    return nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+}
 function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings: true }, nxJson) {
     // this is to lerna case when this function is invoked imperatively
     if (args['target'] && !args['targets']) {
@@ -70,7 +74,7 @@ function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings:
                 ],
             });
         }
-        // Allow setting base and head via environment variables (lower priority then direct command arguments)
+        // Allow setting base and head via environment variables (lower priority than direct command arguments)
         if (!nxArgs.base && process.env.NX_BASE) {
             nxArgs.base = process.env.NX_BASE;
             if (options.printWarnings) {
@@ -88,8 +92,7 @@ function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings:
             }
         }
         if (!nxArgs.base) {
-            nxArgs.base =
-                nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+            nxArgs.base = getBaseRef(nxJson);
             // No user-provided arguments to set the affected criteria, so inform the user of the defaults being used
             if (options.printWarnings &&
                 !nxArgs.head &&

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

@@ -1,3 +1,38 @@
+import { ExecSyncOptions } from 'child_process';
+export declare function cloneFromUpstream(url: string, destination: string, { originName }?: {
+    originName: string;
+}): Promise<GitRepository>;
+export declare class GitRepository {
+    private directory;
+    root: string;
+    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: {
+        new: boolean;
+        base: string;
+    }): Promise<string>;
+    move(path: string, destination: string): Promise<string>;
+    push(ref: string, remoteName: string): Promise<string>;
+    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>;
+}
+/**
+ * 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;
 export declare function getGithubSlugOrNull(): string | null;
 export declare function extractUserAndRepoFromGitHubUrl(gitRemotes: string): string | null;
 export declare function commitChanges(commitMessage: string, directory?: string): string | null;

package/src/utils/git-utils.js

@@ -1,11 +1,122 @@
 "use strict";
 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');
+function execAsync(command, execOptions) {
+    return new Promise((res, rej) => {
+        (0, child_process_1.exec)(command, execOptions, (err, stdout, stderr) => {
+            if (err) {
+                return rej(err);
+            }
+            res(stdout);
+        });
+    });
+}
+async function cloneFromUpstream(url, destination, { originName } = { originName: 'origin' }) {
+    await execAsync(`git clone ${url} ${destination} --depth 1 --origin ${originName}`, {
+        cwd: (0, path_1.dirname)(destination),
+    });
+    return new GitRepository(destination);
+}
+class GitRepository {
+    constructor(directory) {
+        this.directory = directory;
+        this.root = this.getGitRootPath(this.directory);
+    }
+    getGitRootPath(cwd) {
+        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd,
+        })
+            .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 showStat() {
+        return await this.execAsync(`git show --stat`);
+    }
+    async listBranches() {
+        return (await this.execAsync(`git ls-remote --heads --quiet`))
+            .trim()
+            .split('\n')
+            .map((s) => s
+            .trim()
+            .substring(s.indexOf('\t') + 1)
+            .replace('refs/heads/', ''));
+    }
+    async getGitFiles(path) {
+        return (await this.execAsync(`git ls-files ${path}`))
+            .trim()
+            .split('\n')
+            .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`);
+    }
+    async mergeUnrelatedHistories(ref, message) {
+        return this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+    }
+    async fetch(remote, ref) {
+        return this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+    }
+    async checkout(branch, opts) {
+        return this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+    }
+    async move(path, destination) {
+        return this.execAsync(`git mv ${path} ${destination}`);
+    }
+    async push(ref, remoteName) {
+        return this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+    }
+    async commit(message) {
+        return this.execAsync(`git commit -am "${message}"`);
+    }
+    async amendCommit() {
+        return this.execAsync(`git commit --amend -a --no-edit`);
+    }
+    deleteGitRemote(name) {
+        return this.execAsync(`git remote rm ${name}`);
+    }
+    deleteBranch(branch) {
+        return this.execAsync(`git branch -D ${branch}`);
+    }
+    addGitRemote(name, url) {
+        return this.execAsync(`git remote add ${name} ${url}`);
+    }
+}
+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);
+}
 function getGithubSlugOrNull() {
     try {
         const gitRemote = (0, child_process_1.execSync)('git remote -v', {

package/src/utils/package-manager.js

@@ -49,7 +49,7 @@ function isWorkspacesEnabled(packageManager = detectPackageManager(), root = wor
     if (packageManager === 'pnpm') {
         return (0, fs_1.existsSync)((0, path_1.join)(root, 'pnpm-workspace.yaml'));
     }
-    // yarn and pnpm both use the same 'workspaces' property in package.json
+    // yarn and npm both use the same 'workspaces' property in package.json
     const packageJson = (0, file_utils_1.readPackageJson)();
     return !!packageJson?.workspaces;
 }

package/src/utils/squash.d.ts

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

package/src/utils/squash.js

@@ -0,0 +1,12 @@
+"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);