get-changed-packages.ts

import nodePath from "path";
import { assembleReleasePlan } from "@changesets/assemble-release-plan";
import { validateConfig } from "@changesets/config";
import { parseChangesetFile } from "@changesets/parse";
import type {
  NewChangeset,
  Package,
  Packages,
  PreState,
  WrittenConfig,
  PackageJSON as ChangesetPackageJSON,
} from "@changesets/types";
import micromatch from "micromatch";
import type { ProbotOctokit } from "probot";
import subset from "semver/ranges/subset.js";
import * as yaml from "yaml";
import { isChangeset } from "./is-changeset.ts";

interface PackageJSON extends ChangesetPackageJSON {
  workspaces?: ReadonlyArray<string> | { packages: ReadonlyArray<string> };
  bolt?: { workspaces: ReadonlyArray<string> };
}

interface PnpmWorkspace {
  packages: ReadonlyArray<string>;
}

type ToolType = Packages["tool"]["type"];

/** Expected validation failures that should be surfaced in the PR comment. */
export class UserValidationError extends Error {}

const changesetsV2Range = ">=2.0.0 <3.0.0";

function isChangesetsV2Range(declaredVersion: string | undefined) {
  if (declaredVersion === undefined) {
    return false;
  }

  try {
    return subset(declaredVersion, changesetsV2Range);
  } catch {
    return false;
  }
}

function getReleasePlanConfig(
  rawConfig: WrittenConfig & { prettier?: unknown },
  rootPackageJsonContent: PackageJSON,
): WrittenConfig {
  // The bot only calculates a release plan, so options used exclusively for formatting,
  // writing files, Git comparisons, publishing, and snapshots are intentionally ignored.
  const {
    access: _access,
    baseBranch: _baseBranch,
    changedFilePatterns: _changedFilePatterns,
    changelog: _changelog,
    commit: _commit,
    format: _format,
    prettier: _prettier,
    snapshot: _snapshot,
    ...releasePlanConfig
  } = rawConfig;

  const declaredChangesetsVersion =
    rootPackageJsonContent.devDependencies?.["@changesets/cli"] ??
    rootPackageJsonContent.dependencies?.["@changesets/cli"];
  if (!isChangesetsV2Range(declaredChangesetsVersion)) {
    return releasePlanConfig;
  }

  const privatePackages = rawConfig.privatePackages;
  if (!("privatePackages" in rawConfig)) {
    return { ...releasePlanConfig, privatePackages: { version: true } };
  }
  if (privatePackages === true) {
    throw new UserValidationError(
      "The `privatePackages` option can only be `false` or an object when using Changesets v2.",
    );
  }
  // Changesets v2 defaulted an omitted `version` to `true` even inside the object form.
  // Only adapt that valid shape; invalid values must pass through to `validateConfig`.
  if (
    typeof privatePackages === "object" &&
    privatePackages !== null &&
    !Array.isArray(privatePackages) &&
    !("version" in privatePackages)
  ) {
    return {
      ...releasePlanConfig,
      privatePackages: { version: true, ...privatePackages },
    };
  }
  return releasePlanConfig;
}

// TODO: it might be possible to remove this if improvements to `Array.isArray` ever land
// related thread: github.com/microsoft/TypeScript/issues/36554
function isArray<T>(
  arg: T | {},
): arg is T extends ReadonlyArray<any>
  ? unknown extends T
    ? never
    : ReadonlyArray<any>
  : Array<any> {
  return Array.isArray(arg);
}

export const getChangedPackages = async ({
  owner,
  repo,
  ref,
  changedFiles: changedFilesPromise,
  octokit,
  installationToken,
}: {
  owner: string;
  repo: string;
  ref: string;
  changedFiles: ReadonlyArray<string> | Promise<ReadonlyArray<string>>;
  octokit: InstanceType<typeof ProbotOctokit>;
  installationToken: string;
}) => {
  let hasErrored = false;
  const encodedCredentials = Buffer.from(`x-access-token:${installationToken}`).toString("base64");

  function fetchFile(path: string) {
    return fetch(`https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path}`, {
      headers: {
        Authorization: `Basic ${encodedCredentials}`,
      },
    });
  }

  async function fetchJsonFile<T>(path: string): Promise<T> {
    try {
      const x = await fetchFile(path);
      return x.json() as Promise<T>;
    } catch (error) {
      hasErrored = true;
      console.error(error);
      return {} as Promise<T>;
    }
  }

  async function fetchTextFile(path: string): Promise<string> {
    try {
      const x = await fetchFile(path);
      return x.text();
    } catch (err) {
      hasErrored = true;
      console.error(err);
      return "";
    }
  }

  async function getPackage(pkgPath: string): Promise<{ dir: string; packageJson: PackageJSON }> {
    const jsonContent = await fetchJsonFile(pkgPath + "/package.json");
    return {
      dir: pkgPath,
      packageJson: jsonContent as PackageJSON,
    };
  }

  const rootPackageJsonContentsPromise: Promise<PackageJSON> = fetchJsonFile("package.json");
  const rawConfigPromise: Promise<WrittenConfig> = fetchJsonFile(".changeset/config.json");

  const tree = await octokit.git.getTree({
    owner,
    repo,
    recursive: "1",
    tree_sha: ref,
  });

  let preStatePromise: Promise<PreState> | undefined;
  const changesetPromises: Array<Promise<NewChangeset>> = [];
  const potentialWorkspaceDirectories: Array<string> = [];
  let isPnpm = false;
  const changedFiles = await changedFilesPromise;

  for (const item of tree.data.tree) {
    if (!item.path) {
      continue;
    }
    if (nodePath.basename(item.path) === "package.json") {
      const dirPath = nodePath.dirname(item.path);
      potentialWorkspaceDirectories.push(dirPath);
    } else if (item.path === "pnpm-workspace.yaml") {
      isPnpm = true;
    } else if (item.path === ".changeset/pre.json") {
      preStatePromise = fetchJsonFile(".changeset/pre.json");
    } else if (changedFiles.includes(item.path) && isChangeset(item.path)) {
      const res = /\.changeset\/([^.]+)\.md/.exec(item.path);
      if (!res) {
        throw new Error("could not get name from changeset filename");
      }
      const id = res[1];

      changesetPromises.push(
        fetchTextFile(item.path).then((text) => {
          try {
            return {
              ...parseChangesetFile(text),
              id,
            };
          } catch (error) {
            throw new UserValidationError(Error.isError(error) ? error.message : String(error), {
              cause: error,
            });
          }
        }),
      );
    }
  }
  let tool:
    | {
        type: ToolType;
        globs: ReadonlyArray<string>;
      }
    | undefined;

  if (isPnpm) {
    const pnpmWorkspaceContent = await fetchTextFile("pnpm-workspace.yaml");
    const pnpmWorkspace = yaml.parse(pnpmWorkspaceContent) as PnpmWorkspace;

    if (pnpmWorkspace.packages) {
      tool = {
        type: "pnpm",
        globs: pnpmWorkspace.packages,
      };
    }
  } else {
    const rootPackageJsonContent = await rootPackageJsonContentsPromise;

    if (rootPackageJsonContent.workspaces) {
      if (isArray(rootPackageJsonContent.workspaces)) {
        tool = {
          type: "yarn",
          globs: rootPackageJsonContent.workspaces,
        };
      } else {
        tool = {
          type: "yarn",
          globs: rootPackageJsonContent.workspaces.packages,
        };
      }
    } else if (rootPackageJsonContent.bolt && rootPackageJsonContent.bolt.workspaces) {
      tool = {
        type: "bolt",
        globs: rootPackageJsonContent.bolt.workspaces,
      };
    }
  }

  const rootPackageJsonContent = await rootPackageJsonContentsPromise;

  const rootPackage: Package = {
    dir: "/",
    packageJson: rootPackageJsonContent,
  };

  const packages: Packages = {
    rootDir: "/",
    rootPackage,
    tool: { type: tool ? tool.type : "root" },
    packages: [],
  };

  if (tool) {
    if (
      !Array.isArray(tool.globs) ||
      !tool.globs.every((glob: unknown) => typeof glob === "string")
    ) {
      throw new Error("globs are not valid: " + JSON.stringify(tool.globs));
    }
    const matches = micromatch(potentialWorkspaceDirectories, tool.globs);

    packages.packages = await Promise.all(matches.map((dir) => getPackage(dir)));
  } else {
    packages.packages.push(rootPackage);
  }
  if (hasErrored) {
    throw new Error("an error occurred when fetching files");
  }

  const rawConfig = await rawConfigPromise;

  const configResult = validateConfig(
    getReleasePlanConfig(rawConfig, rootPackageJsonContent),
    packages,
  );

  if (configResult.errors) {
    throw new UserValidationError(
      "Some errors occurred when validating the changesets config:\n" +
        configResult.errors.join("\n"),
    );
  }

  const releasePlan = assembleReleasePlan(
    await Promise.all(changesetPromises),
    packages,
    configResult.config,
    await preStatePromise,
  );

  // A root-only project has a single package covering the whole repository,
  // so there is no directory to narrow the changed files down to.
  const changedPackages =
    packages.tool.type === "root"
      ? packages.packages
      : packages.packages.filter((pkg) =>
          changedFiles.some((changedFile) => changedFile.startsWith(`${pkg.dir}/`)),
        );

  return {
    changedPackages: changedPackages.map((pkg) => pkg.packageJson.name),
    releasePlan,
  };
};