workspace-tools 0.23.2 → 0.25.0

package/lib/git/gitUtilities.js

@@ -0,0 +1,286 @@
+"use strict";
+//
+// Assorted other git utilities
+// (could be split into separate files later if desired)
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAllTrackedFiles = exports.getDefaultBranch = exports.parseRemoteBranch = exports.getRemoteBranch = exports.getParentBranch = exports.revertLocalChanges = exports.stageAndCommit = exports.commit = exports.stage = exports.init = exports.getFileAddedHash = exports.getCurrentHash = exports.getShortBranchName = exports.getFullBranchRef = exports.getBranchName = exports.getUserEmail = exports.getRecentCommitMessages = exports.getStagedChanges = exports.getChangesBetweenRefs = exports.getBranchChanges = exports.getChanges = exports.getUnstagedChanges = exports.fetchRemoteBranch = exports.fetchRemote = exports.getUntrackedChanges = void 0;
+const git_1 = require("./git");
+function getUntrackedChanges(cwd) {
+    try {
+        const results = (0, git_1.git)(["status", "--short"], { cwd });
+        if (!results.success || !results.stdout) {
+            return [];
+        }
+        const lines = results.stdout.split(/[\r\n]+/).filter((line) => line);
+        const untracked = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line[0] === " " || line[0] === "?") {
+                untracked.push(line.substring(3));
+            }
+            else if (line[0] === "R") {
+                i++;
+            }
+        }
+        return untracked;
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about untracked changes`, e);
+    }
+}
+exports.getUntrackedChanges = getUntrackedChanges;
+function fetchRemote(remote, cwd) {
+    const results = (0, git_1.git)(["fetch", "--", remote], { cwd });
+    if (!results.success) {
+        throw new git_1.GitError(`Cannot fetch remote "${remote}"`);
+    }
+}
+exports.fetchRemote = fetchRemote;
+function fetchRemoteBranch(remote, remoteBranch, cwd) {
+    const results = (0, git_1.git)(["fetch", "--", remote, remoteBranch], { cwd });
+    if (!results.success) {
+        throw new git_1.GitError(`Cannot fetch branch "${remoteBranch}" from remote "${remote}"`);
+    }
+}
+exports.fetchRemoteBranch = fetchRemoteBranch;
+/**
+ * Gets all the changes that have not been staged yet
+ * @param cwd
+ */
+function getUnstagedChanges(cwd) {
+    try {
+        return processGitOutput((0, git_1.git)(["--no-pager", "diff", "--name-only", "--relative"], { cwd }));
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about unstaged changes`, e);
+    }
+}
+exports.getUnstagedChanges = getUnstagedChanges;
+function getChanges(branch, cwd) {
+    try {
+        return processGitOutput((0, git_1.git)(["--no-pager", "diff", "--relative", "--name-only", branch + "..."], { cwd }));
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about changes`, e);
+    }
+}
+exports.getChanges = getChanges;
+/**
+ * Gets all the changes between the branch and the merge-base
+ */
+function getBranchChanges(branch, cwd) {
+    return getChangesBetweenRefs(branch, "", [], "", cwd);
+}
+exports.getBranchChanges = getBranchChanges;
+function getChangesBetweenRefs(fromRef, toRef, options, pattern, cwd) {
+    try {
+        return processGitOutput((0, git_1.git)([
+            "--no-pager",
+            "diff",
+            "--name-only",
+            "--relative",
+            ...options,
+            `${fromRef}...${toRef}`,
+            ...(pattern ? ["--", pattern] : []),
+        ], { cwd }));
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about change between refs changes (${fromRef} to ${toRef})`, e);
+    }
+}
+exports.getChangesBetweenRefs = getChangesBetweenRefs;
+function getStagedChanges(cwd) {
+    try {
+        return processGitOutput((0, git_1.git)(["--no-pager", "diff", "--relative", "--staged", "--name-only"], { cwd }));
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about staged changes`, e);
+    }
+}
+exports.getStagedChanges = getStagedChanges;
+function getRecentCommitMessages(branch, cwd) {
+    try {
+        const results = (0, git_1.git)(["log", "--decorate", "--pretty=format:%s", `${branch}..HEAD`], { cwd });
+        if (!results.success) {
+            return [];
+        }
+        return results.stdout.split(/\n/).map((line) => line.trim());
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about recent commits`, e);
+    }
+}
+exports.getRecentCommitMessages = getRecentCommitMessages;
+function getUserEmail(cwd) {
+    try {
+        const results = (0, git_1.git)(["config", "user.email"], { cwd });
+        return results.success ? results.stdout : null;
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about user.email`, e);
+    }
+}
+exports.getUserEmail = getUserEmail;
+function getBranchName(cwd) {
+    try {
+        const results = (0, git_1.git)(["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+        return results.success ? results.stdout : null;
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot get branch name`, e);
+    }
+}
+exports.getBranchName = getBranchName;
+function getFullBranchRef(branch, cwd) {
+    const showRefResults = (0, git_1.git)(["show-ref", "--heads", branch], { cwd });
+    return showRefResults.success ? showRefResults.stdout.split(" ")[1] : null;
+}
+exports.getFullBranchRef = getFullBranchRef;
+function getShortBranchName(fullBranchRef, cwd) {
+    const showRefResults = (0, git_1.git)(["name-rev", "--name-only", fullBranchRef], {
+        cwd,
+    });
+    return showRefResults.success ? showRefResults.stdout : null;
+}
+exports.getShortBranchName = getShortBranchName;
+function getCurrentHash(cwd) {
+    try {
+        const results = (0, git_1.git)(["rev-parse", "HEAD"], { cwd });
+        return results.success ? results.stdout : null;
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot get current git hash`, e);
+    }
+}
+exports.getCurrentHash = getCurrentHash;
+/**
+ * Get the commit hash in which the file was first added.
+ */
+function getFileAddedHash(filename, cwd) {
+    const results = (0, git_1.git)(["rev-list", "HEAD", filename], { cwd });
+    if (results.success) {
+        return results.stdout.trim().split("\n").slice(-1)[0];
+    }
+    return undefined;
+}
+exports.getFileAddedHash = getFileAddedHash;
+function init(cwd, email, username) {
+    (0, git_1.git)(["init"], { cwd });
+    const configLines = (0, git_1.git)(["config", "--list"], { cwd }).stdout.split("\n");
+    if (!configLines.find((line) => line.includes("user.name"))) {
+        if (!username) {
+            throw new git_1.GitError("must include a username when initializing git repo");
+        }
+        (0, git_1.git)(["config", "user.name", username], { cwd });
+    }
+    if (!configLines.find((line) => line.includes("user.email"))) {
+        if (!email) {
+            throw new Error("must include a email when initializing git repo");
+        }
+        (0, git_1.git)(["config", "user.email", email], { cwd });
+    }
+}
+exports.init = init;
+function stage(patterns, cwd) {
+    try {
+        patterns.forEach((pattern) => {
+            (0, git_1.git)(["add", pattern], { cwd });
+        });
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot stage changes`, e);
+    }
+}
+exports.stage = stage;
+function commit(message, cwd, options = []) {
+    try {
+        const commitResults = (0, git_1.git)(["commit", "-m", message, ...options], { cwd });
+        if (!commitResults.success) {
+            throw new Error(`Cannot commit changes: ${commitResults.stdout} ${commitResults.stderr}`);
+        }
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot commit changes`, e);
+    }
+}
+exports.commit = commit;
+function stageAndCommit(patterns, message, cwd, commitOptions = []) {
+    stage(patterns, cwd);
+    commit(message, cwd, commitOptions);
+}
+exports.stageAndCommit = stageAndCommit;
+function revertLocalChanges(cwd) {
+    const stash = `workspace-tools_${new Date().getTime()}`;
+    (0, git_1.git)(["stash", "push", "-u", "-m", stash], { cwd });
+    const results = (0, git_1.git)(["stash", "list"]);
+    if (results.success) {
+        const lines = results.stdout.split(/\n/);
+        const foundLine = lines.find((line) => line.includes(stash));
+        if (foundLine) {
+            const matched = foundLine.match(/^[^:]+/);
+            if (matched) {
+                (0, git_1.git)(["stash", "drop", matched[0]]);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+exports.revertLocalChanges = revertLocalChanges;
+function getParentBranch(cwd) {
+    const branchName = getBranchName(cwd);
+    if (!branchName || branchName === "HEAD") {
+        return null;
+    }
+    const showBranchResult = (0, git_1.git)(["show-branch", "-a"], { cwd });
+    if (showBranchResult.success) {
+        const showBranchLines = showBranchResult.stdout.split(/\n/);
+        const parentLine = showBranchLines.find((line) => line.includes("*") && !line.includes(branchName) && !line.includes("publish_"));
+        const matched = parentLine === null || parentLine === void 0 ? void 0 : parentLine.match(/\[(.*)\]/);
+        return matched ? matched[1] : null;
+    }
+    return null;
+}
+exports.getParentBranch = getParentBranch;
+function getRemoteBranch(branch, cwd) {
+    const results = (0, git_1.git)(["rev-parse", "--abbrev-ref", "--symbolic-full-name", `${branch}@\{u\}`], { cwd });
+    if (results.success) {
+        return results.stdout.trim();
+    }
+    return null;
+}
+exports.getRemoteBranch = getRemoteBranch;
+function parseRemoteBranch(branch) {
+    const firstSlashPos = branch.indexOf("/", 0);
+    const remote = branch.substring(0, firstSlashPos);
+    const remoteBranch = branch.substring(firstSlashPos + 1);
+    return {
+        remote,
+        remoteBranch,
+    };
+}
+exports.parseRemoteBranch = parseRemoteBranch;
+/**
+ * Gets the default branch based on `git config init.defaultBranch`, falling back to `master`.
+ */
+function getDefaultBranch(cwd) {
+    const result = (0, git_1.git)(["config", "init.defaultBranch"], { cwd });
+    // Default to the legacy 'master' for backwards compat and old git clients
+    return result.success ? result.stdout.trim() : "master";
+}
+exports.getDefaultBranch = getDefaultBranch;
+function listAllTrackedFiles(patterns, cwd) {
+    const results = (0, git_1.git)(["ls-files", ...patterns], { cwd });
+    return results.success ? results.stdout.split(/\n/) : [];
+}
+exports.listAllTrackedFiles = listAllTrackedFiles;
+function processGitOutput(output) {
+    if (!output.success) {
+        return [];
+    }
+    return output.stdout
+        .split(/\n/)
+        .map((line) => line.trim())
+        .filter((line) => !!line && !line.includes("node_modules"));
+}

package/lib/git/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./git";
+export * from "./getDefaultRemote";
+export * from "./getDefaultRemoteBranch";
+export * from "./gitUtilities";

package/lib/git/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./git"), exports);
+__exportStar(require("./getDefaultRemote"), exports);
+__exportStar(require("./getDefaultRemoteBranch"), exports);
+__exportStar(require("./gitUtilities"), exports);
+// getRepositoryName is not currently exported; could be changed if it would be useful externally

package/lib/graph/index.d.ts

@@ -1,3 +1,8 @@
 export * from "./createPackageGraph";
 import { PackageInfos } from "../types/PackageInfo";
+/**
+ * @deprecated - use createDependencyMap() instead
+ *
+ * Gets a map that has the package name as key, and its dependencies as values
+ */
 export declare function getDependentMap(packages: PackageInfos): Map<string, Set<string>>;

package/lib/graph/index.js

@@ -13,8 +13,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDependentMap = void 0;
 __exportStar(require("./createPackageGraph"), exports);
 const createDependencyMap_1 = require("./createDependencyMap");
-// @deprecated - use createDependencyMap() instead
+/**
+ * @deprecated - use createDependencyMap() instead
+ *
+ * Gets a map that has the package name as key, and its dependencies as values
+ */
 function getDependentMap(packages) {
-    return (0, createDependencyMap_1.createDependencyMap)(packages).dependents;
+    return (0, createDependencyMap_1.createDependencyMap)(packages).dependencies;
 }
 exports.getDependentMap = getDependentMap;

package/lib/helpers/setupFixture.d.ts

@@ -1,7 +1,13 @@
+import { PackageInfo } from "../types/PackageInfo";
 /**
  * Create a temp directory containing the given fixture name in a git repo.
  * Be sure to call `cleanupFixtures()` after all tests to clean up temp directories.
  */
-export declare function setupFixture(fixtureName: string): string;
+export declare function setupFixture(fixtureName?: string): string;
+/**
+ * `tmp` is not always reliable about cleanup even with appropriate options, so it's recommended to
+ * call this function in `afterAll`.
+ */
 export declare function cleanupFixtures(): void;
-export declare function setupLocalRemote(cwd: string, remoteName: string, fixtureName: string): void;
+export declare function setupPackageJson(cwd: string, packageJson?: Partial<PackageInfo>): void;
+export declare function setupLocalRemote(cwd: string, remoteName: string, fixtureName?: string): void;

package/lib/helpers/setupFixture.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupLocalRemote = exports.cleanupFixtures = exports.setupFixture = void 0;
+exports.setupLocalRemote = exports.setupPackageJson = exports.cleanupFixtures = exports.setupFixture = void 0;
 const path_1 = __importDefault(require("path"));
 const find_up_1 = __importDefault(require("find-up"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -13,6 +13,7 @@ const git_1 = require("../git");
 // So we attempt to use its built-in cleanup mechanisms, but tests should ideally do their own cleanup too.
 tmp_1.default.setGracefulCleanup();
 let fixturesRoot;
+// Temp directories are created under tempRoot.name with incrementing numeric sub-directories
 let tempRoot;
 let tempNumber = 0;
 /**
@@ -20,20 +21,23 @@ let tempNumber = 0;
  * Be sure to call `cleanupFixtures()` after all tests to clean up temp directories.
  */
 function setupFixture(fixtureName) {
-    if (!fixturesRoot) {
-        fixturesRoot = find_up_1.default.sync("__fixtures__", { cwd: __dirname, type: "directory" });
-    }
-    const fixturePath = path_1.default.join(fixturesRoot, fixtureName);
-    if (!fs_extra_1.default.existsSync(fixturePath)) {
-        throw new Error(`Couldn't find fixture "${fixtureName}" under "${fixturesRoot}"`);
+    let fixturePath;
+    if (fixtureName) {
+        if (!fixturesRoot) {
+            fixturesRoot = find_up_1.default.sync("__fixtures__", { cwd: __dirname, type: "directory" });
+        }
+        fixturePath = path_1.default.join(fixturesRoot, fixtureName);
+        if (!fs_extra_1.default.existsSync(fixturePath)) {
+            throw new Error(`Couldn't find fixture "${fixtureName}" under "${fixturesRoot}"`);
+        }
     }
     if (!tempRoot) {
         // Create a shared root temp directory for fixture files
         tempRoot = tmp_1.default.dirSync({ unsafeCleanup: true }); // clean up even if files are left
     }
-    const cwd = path_1.default.join(tempRoot.name, String(tempNumber++), fixtureName);
+    // Make the directory and git init
+    const cwd = path_1.default.join(tempRoot.name, String(tempNumber++), fixtureName || "");
     fs_extra_1.default.mkdirpSync(cwd);
-    fs_extra_1.default.copySync(fixturePath, cwd);
     (0, git_1.init)(cwd, "test@test.email", "test user");
     // Ensure GPG signing doesn't interfere with tests
     (0, git_1.gitFailFast)(["config", "commit.gpgsign", "false"], { cwd });
@@ -43,10 +47,18 @@ function setupFixture(fixtureName) {
     // a 'fixed' value for our tests, regardless of user configuration
     (0, git_1.gitFailFast)(["symbolic-ref", "HEAD", "refs/heads/main"], { cwd });
     (0, git_1.gitFailFast)(["config", "init.defaultBranch", "main"], { cwd });
-    (0, git_1.stageAndCommit)(["."], "test", cwd);
+    // Copy and commit the fixture if requested
+    if (fixturePath) {
+        fs_extra_1.default.copySync(fixturePath, cwd);
+        (0, git_1.stageAndCommit)(["."], "test", cwd);
+    }
     return cwd;
 }
 exports.setupFixture = setupFixture;
+/**
+ * `tmp` is not always reliable about cleanup even with appropriate options, so it's recommended to
+ * call this function in `afterAll`.
+ */
 function cleanupFixtures() {
     if (tempRoot) {
         tempRoot.removeCallback();
@@ -54,16 +66,21 @@ function cleanupFixtures() {
     }
 }
 exports.cleanupFixtures = cleanupFixtures;
+function setupPackageJson(cwd, packageJson = {}) {
+    const pkgJsonPath = path_1.default.join(cwd, "package.json");
+    let oldPackageJson;
+    if (fs_extra_1.default.existsSync(pkgJsonPath)) {
+        oldPackageJson = JSON.parse(fs_extra_1.default.readFileSync(pkgJsonPath, "utf-8"));
+    }
+    fs_extra_1.default.writeFileSync(pkgJsonPath, JSON.stringify(Object.assign(Object.assign({}, oldPackageJson), packageJson), null, 2));
+}
+exports.setupPackageJson = setupPackageJson;
 function setupLocalRemote(cwd, remoteName, fixtureName) {
     // Create a seperate repo and configure it as a remote
     const remoteCwd = setupFixture(fixtureName);
     const remoteUrl = remoteCwd.replace(/\\/g, "/");
     (0, git_1.gitFailFast)(["remote", "add", remoteName, remoteUrl], { cwd });
     // Configure url in package.json
-    const pkgJsonPath = path_1.default.join(cwd, "package.json");
-    const pkgJson = JSON.parse(fs_extra_1.default.readFileSync(pkgJsonPath, "utf-8"));
-    fs_extra_1.default.writeFileSync(pkgJsonPath, JSON.stringify(Object.assign(Object.assign({}, pkgJson), { repository: {
-            url: remoteUrl,
-        } }), null, 2));
+    setupPackageJson(cwd, { repository: { url: remoteUrl, type: "git" } });
 }
 exports.setupLocalRemote = setupLocalRemote;

package/lib/paths.d.ts

@@ -3,9 +3,10 @@
  */
 export declare function searchUp(pathName: string, cwd: string): string | null;
 /**
- * Starting from `cwd`, searches up the directory hierarchy for `.git`.
+ * Starting from `cwd`, uses `git rev-parse --show-toplevel` to find the root of the git repo.
+ * Throws if `cwd` is not in a Git repository.
  */
-export declare function findGitRoot(cwd: string): string | null;
+export declare function findGitRoot(cwd: string): string;
 /**
  * Starting from `cwd`, searches up the directory hierarchy for `package.json`.
  */
@@ -14,5 +15,5 @@ export declare function findPackageRoot(cwd: string): string | null;
  * Starting from `cwd`, searches up the directory hierarchy for the workspace root,
  * falling back to the git root if no workspace is detected.
  */
-export declare function findProjectRoot(cwd: string): string | null;
+export declare function findProjectRoot(cwd: string): string;
 export declare function isChildOf(child: string, parent: string): boolean;

package/lib/paths.js

@@ -7,6 +7,7 @@ exports.isChildOf = exports.findProjectRoot = exports.findPackageRoot = exports.
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const getWorkspaceRoot_1 = require("./workspaces/getWorkspaceRoot");
+const git_1 = require("./git");
 /**
  * Starting from `cwd`, searches up the directory hierarchy for `pathName`.
  */
@@ -27,10 +28,15 @@ function searchUp(pathName, cwd) {
 }
 exports.searchUp = searchUp;
 /**
- * Starting from `cwd`, searches up the directory hierarchy for `.git`.
+ * Starting from `cwd`, uses `git rev-parse --show-toplevel` to find the root of the git repo.
+ * Throws if `cwd` is not in a Git repository.
  */
 function findGitRoot(cwd) {
-    return searchUp(".git", cwd);
+    const output = (0, git_1.git)(["rev-parse", "--show-toplevel"], { cwd });
+    if (!output.success) {
+        throw new Error(`Directory "${cwd}" is not in a git repository`);
+    }
+    return path_1.default.normalize(output.stdout);
 }
 exports.findGitRoot = findGitRoot;
 /**

package/lib/types/PackageInfo.d.ts

@@ -14,11 +14,14 @@ export interface PackageInfo {
     private?: boolean;
     group?: string;
     scripts?: {
-        [dep: string]: string;
+        [scriptName: string]: string;
     };
-    [key: string]: string | boolean | string[] | {
-        [dep: string]: string;
-    } | undefined;
+    repository?: string | {
+        type: string;
+        url: string;
+        directory?: string;
+    };
+    [key: string]: any;
 }
 export interface PackageInfos {
     [pkgName: string]: PackageInfo;

package/lib/workspaces/getChangedPackages.js

@@ -50,7 +50,7 @@ exports.getChangedPackagesBetweenRefs = getChangedPackagesBetweenRefs;
  * @returns string[] of package names that have changed
  */
 function getChangedPackages(cwd, target, ignoreGlobs = []) {
-    const targetBranch = target || (0, git_1.getDefaultRemoteBranch)(undefined, cwd);
+    const targetBranch = target || (0, git_1.getDefaultRemoteBranch)({ cwd });
     let changes = [
         ...new Set([
             ...((0, git_1.getUntrackedChanges)(cwd) || []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workspace-tools",
-  "version": "0.23.2",
+  "version": "0.25.0",
   "license": "MIT",
   "repository": {
     "type": "git",