@edifice.io/cli 1.6.0-develop.7 → 1.6.0-develop.8

package/bin/index.js

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 
-import { program } from 'commander';
-import interpret from 'interpret';
-import Liftoff from 'liftoff';
-import minimist from 'minimist';
-import { readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { dirname, join } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import v8flags from 'v8flags';
-import { publish } from '../scripts/publish.js';
+import { program } from "commander";
+import interpret from "interpret";
+import Liftoff from "liftoff";
+import minimist from "minimist";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import v8flags from "v8flags";
+import { publish } from "../src/publish/index.js";
 
 const args = process.argv.slice(2);
 const argv = minimist(args);
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(
-  readFileSync(join(__dirname, '../package.json'), 'utf8')
+  readFileSync(join(__dirname, "../package.json"), "utf8"),
 );
 
 const require = createRequire(import.meta.url);
@@ -30,7 +30,7 @@ async function requireOrImport(path) {
     return require(path);
   } catch (e) {
     // @ts-expect-error
-    if (e.code === 'ERR_REQUIRE_ESM') {
+    if (e.code === "ERR_REQUIRE_ESM") {
       // This is needed on Windows, because import() fails if providing a Windows file path.
       const url = pathToFileURL(path);
       // @ts-expect-error
@@ -41,11 +41,11 @@ async function requireOrImport(path) {
 }
 
 const Config = new Liftoff({
-  name: 'edifice-config',
-  configName: 'edifice.config',
+  name: "edifice-config",
+  configName: "edifice.config",
   // @ts-expect-error
   extensions: interpret.jsVariants,
-  preload: 'esbuild-register/dist/node',
+  preload: "esbuild-register/dist/node",
   v8flags,
 });
 
@@ -56,11 +56,11 @@ function checkForConfigFile(configPath) {
   if (configPath) return;
   console.error(
     [
-      'No edifice.config.js file found!',
+      "No edifice.config.js file found!",
       "This may be because you're not passing the --config or --cwd flags.",
-      'If you are passing these flags, check that the path is correct.',
-      'Otherwise, you can create a `edifice.config.js` file in your project root.',
-    ].join('\n')
+      "If you are passing these flags, check that the path is correct.",
+      "Otherwise, you can create a `edifice.config.js` file in your project root.",
+    ].join("\n"),
   );
   process.exit(1);
 }
@@ -76,30 +76,30 @@ Config.prepare(
       requireOrImport(env.configPath)
         .then((configOpts) => {
           program
-            .name('@edifice.io/cli')
+            .name("@edifice.io/cli")
             .description(
-              'Configuration and tools for publishing and maintaining packages'
+              "Configuration and tools for publishing and maintaining packages",
             )
             .version(pkg.version);
 
           if (configOpts) {
             for (const key of Object.keys(configOpts)) {
-              program.setOptionValueWithSource(key, configOpts[key], 'config');
+              program.setOptionValueWithSource(key, configOpts[key], "config");
             }
           }
 
           program
-            .command('publish')
+            .command("publish")
             .description(
-              'Publish your package with the current working directory'
+              "Publish your package with the current working directory",
             )
             .option(
-              '--cwd <dir>',
-              'Current working directory of the configuration file'
+              "--cwd <dir>",
+              "Current working directory of the configuration file",
             )
-            .option('--config <config>', 'The path to the configuration file')
-            .option('--tag <tag>', 'The tag to publish to')
-            .option('--branch <branch>', 'The branch to publish from')
+            .option("--config <config>", "The path to the configuration file")
+            .option("--tag <tag>", "The tag to publish to")
+            .option("--branch <branch>", "The branch to publish from")
             .action((_str, opts) => {
               return publish({
                 branchConfigs: configOpts.publishOptions.branchConfigs,
@@ -121,5 +121,5 @@ Config.prepare(
           process.exit(1);
         });
     });
-  }
+  },
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edifice.io/cli",
-  "version": "1.6.0-develop.7",
+  "version": "1.6.0-develop.8",
   "description": "Edifice Frontend CLI",
   "keywords": [
     "frontend",
@@ -30,7 +30,8 @@
     "edifice-cli": "./bin/index.js"
   },
   "files": [
-    "bin"
+    "bin",
+    "src"
   ],
   "dependencies": {
     "@commitlint/parse": "^19.5.0",

package/src/publish/index.d.ts

@@ -0,0 +1,37 @@
+export type Commit = {
+  hash: string;
+  body: string;
+  subject: string;
+  author_name: string;
+  author_email: string;
+  type: string;
+  scope: string | null | undefined;
+};
+
+export type Package = {
+  name: string;
+  packageDir: string;
+};
+
+export type BranchConfig = {
+  prerelease: boolean;
+  previousVersion?: boolean;
+};
+
+export type Options = {
+  /** Contains config for publishable branches. */
+  branchConfigs: Record<string, BranchConfig>;
+  /** List your npm packages here. The first package will be used as the versioner. */
+  packages: Array<Package>;
+  /** Path to root directory of your project. */
+  rootDir: string;
+  /** The branch to publish. Defaults to the current branch if none supplied. */
+  branch?: string;
+  /** A manual tag to force release. Must start with `v` */
+  tag?: string;
+  /** The GitHub token used to search for user metadata and make a GitHub release. */
+  ghToken?: string;
+  emptyPackageScript?: boolean;
+};
+
+export function publish(options: Options): Promise<void>;

package/src/publish/index.js

@@ -0,0 +1,438 @@
+// @ts-check
+// Originally ported to TS from https://github.com/remix-run/react-router/tree/main/scripts/{version,publish}.js
+
+import { parse as parseCommit } from "@commitlint/parse";
+import currentGitBranch from "current-git-branch";
+import { execSync } from "node:child_process";
+import path from "node:path";
+import * as semver from "semver";
+import { simpleGit } from "simple-git";
+import {
+  capitalize,
+  getSorterFn,
+  readPackageJson,
+  releaseCommitMsg,
+  updatePackageJson,
+} from "./utilities.js";
+
+/**
+ * Execute a script being published
+ * @param {import('./index').Options} options
+ * @returns {Promise<void>}
+ */
+export const publish = async (options) => {
+  const { branchConfigs, packages, rootDir, branch, tag, ghToken } = options;
+
+  const branchName = /** @type {string} */ (branch ?? currentGitBranch());
+  const isMainBranch = branchName === "main";
+  const npmTag = isMainBranch ? "latest" : branchName;
+
+  /** @type {import('./index').BranchConfig | undefined} */
+  const branchConfig = branchConfigs[branchName];
+
+  if (!branchConfig) {
+    throw new Error(`No publish config found for branch: ${branchName}`);
+  }
+
+  // Get tags
+  /** @type {string[]} */
+  const allTags = execSync("git tag").toString().split("\n");
+
+  const filteredTags = allTags
+    // Ensure tag is valid
+    .filter((t) => semver.valid(t))
+    // Filter tags based on whether the branch is a release or pre-release
+    .filter((t) => {
+      const isPrereleaseTag = semver.prerelease(t) !== null;
+      return branchConfig.prerelease ? isPrereleaseTag : !isPrereleaseTag;
+    })
+    // sort by latest
+    // @ts-ignore
+    .sort(semver.compare);
+
+  // Get the latest tag
+  let latestTag = filteredTags.at(-1);
+  let rangeFrom = latestTag;
+
+  // If RELEASE_ALL is set via a commit subject or body, all packages will be
+  // released regardless if they have changed files matching the package srcDir.
+  let RELEASE_ALL = false;
+
+  // Validate manual tag
+  if (tag) {
+    if (!semver.valid(tag)) {
+      throw new Error(`tag '${tag}' is not a semantically valid version`);
+    }
+    if (!tag.startsWith("v")) {
+      throw new Error(
+        `tag must start with "v" (e.g. v0.0.0). You supplied ${tag}`,
+      );
+    }
+    if (allTags.includes(tag)) {
+      throw new Error(`tag ${tag} has already been released`);
+    }
+  }
+
+  if (!latestTag || tag) {
+    if (tag) {
+      console.info(
+        `Tag is set to ${tag}. This will force release all packages. Publishing...`,
+      );
+      RELEASE_ALL = true;
+
+      // Is it the first release? Is it a major version?
+      if (!latestTag || (semver.patch(tag) === 0 && semver.minor(tag) === 0)) {
+        rangeFrom = "origin/main";
+        latestTag = tag;
+      }
+    } else {
+      throw new Error(
+        "Could not find latest tag! To make a release tag of v0.0.1, run with TAG=v0.0.1",
+      );
+    }
+  }
+
+  console.info(`Git Range: ${rangeFrom}..HEAD`);
+
+  const rawCommitsLog = (
+    await simpleGit().log({ from: rangeFrom, to: "HEAD" })
+  ).all.filter((c) => {
+    const exclude = [
+      c.message.startsWith("Merge branch "), // No merge commits
+      c.message.startsWith(releaseCommitMsg("")), // No example update commits
+    ].some(Boolean);
+
+    return !exclude;
+  });
+
+  //   /**
+  //    * Get the commits since the latest tag
+  //    * @type {import('./index.js').Commit[]}
+  //    */
+  const commitsSinceLatestTag = await Promise.all(
+    rawCommitsLog.map(async (c) => {
+      const parsed = await parseCommit(c.message);
+      return {
+        hash: c.hash.substring(0, 7),
+        body: c.body,
+        subject: parsed.subject ?? "",
+        author_name: c.author_name,
+        author_email: c.author_email,
+        type: parsed.type?.toLowerCase() ?? "other",
+        scope: parsed.scope,
+      };
+    }),
+  );
+
+  console.info(
+    `Parsing ${commitsSinceLatestTag.length} commits since ${rangeFrom}...`,
+  );
+
+  /**
+   * Parses the commit messages, logs them, and determines the type of release needed
+   * -1 means no release is necessary
+   * 0 means patch release is necessary
+   * 1 means minor release is necessary
+   * 2 means major release is necessary
+   * @type {number}
+   */
+  let recommendedReleaseLevel = commitsSinceLatestTag.reduce(
+    (releaseLevel, commit) => {
+      if (commit.type) {
+        if (["fix", "refactor", "perf"].includes(commit.type)) {
+          releaseLevel = Math.max(releaseLevel, 0);
+        }
+        if (["feat"].includes(commit.type)) {
+          releaseLevel = Math.max(releaseLevel, 1);
+        }
+        if (commit.body.includes("BREAKING CHANGE")) {
+          releaseLevel = Math.max(releaseLevel, 2);
+        }
+        if (
+          commit.subject.includes("RELEASE_ALL") ||
+          commit.body.includes("RELEASE_ALL")
+        ) {
+          RELEASE_ALL = true;
+        }
+      }
+
+      return releaseLevel;
+    },
+    -1,
+  );
+
+  // If there is a breaking change and no manual tag is set, do not release
+  /* if (recommendedReleaseLevel === 2 && !tag) {
+    throw new Error(
+      'Major versions releases must be tagged and released manually.'
+    );
+  } */
+
+  // If no release is semantically necessary and no manual tag is set, do not release
+  if (recommendedReleaseLevel === -1 && !tag) {
+    console.info(
+      `There have been no changes since ${latestTag} that require a new version. You're good!`,
+    );
+    return;
+  }
+
+  // If no release is semantically necessary but a manual tag is set, do a patch release
+  if (recommendedReleaseLevel === -1 && tag) {
+    recommendedReleaseLevel = 0;
+  }
+
+  const releaseType = branchConfig.prerelease
+    ? "prerelease"
+    : /** @type {const} */ ({ 0: "patch", 1: "minor", 2: "major" })[
+        recommendedReleaseLevel
+      ];
+
+  if (!releaseType) {
+    throw new Error(`Invalid release level: ${recommendedReleaseLevel}`);
+  }
+
+  const version = tag
+    ? semver.parse(tag)?.version
+    : semver.inc(latestTag, releaseType, npmTag);
+
+  if (!version) {
+    throw new Error(
+      [
+        "Invalid version increment from semver.inc()",
+        `- latestTag: ${latestTag}`,
+        `- recommendedReleaseLevel: ${recommendedReleaseLevel}`,
+        `- prerelease: ${branchConfig.prerelease}`,
+      ].join("\n"),
+    );
+  }
+
+  console.log(`Targeting version ${version}...`);
+
+  /**
+   * Uses git diff to determine which files have changed since the latest tag
+   * @type {string[]}
+   */
+  const changedFiles = tag
+    ? []
+    : execSync(`git diff ${latestTag} --name-only`)
+        .toString()
+        .split("\n")
+        .filter(Boolean);
+
+  /** Uses packages and changedFiles to determine which packages have changed */
+  const changedPackages = RELEASE_ALL
+    ? packages
+    : packages.filter((pkg) => {
+        const changed = changedFiles.some(
+          (file) =>
+            file.startsWith(path.join(pkg.packageDir, "src")) ||
+            file.startsWith(path.join(pkg.packageDir, "package.json")),
+        );
+        return changed;
+      });
+
+  // If a package has a dependency that has been updated, we need to update the
+  // package that depends on it as well.
+  // run this multiple times so that dependencies of dependencies are also included
+  for (let runs = 0; runs < 3; runs++) {
+    for (const pkg of packages) {
+      const packageJson = await readPackageJson(
+        path.resolve(rootDir, pkg.packageDir, "package.json"),
+      );
+      const allDependencies = Object.keys(
+        Object.assign(
+          {},
+          packageJson.dependencies ?? {},
+          packageJson.peerDependencies ?? {},
+        ),
+      );
+
+      if (
+        allDependencies.find((dep) =>
+          changedPackages.find((d) => d.name === dep),
+        ) &&
+        !changedPackages.find((d) => d.name === pkg.name)
+      ) {
+        console.info(`  Adding dependency ${pkg.name} to changed packages`);
+        changedPackages.push(pkg);
+      }
+    }
+  }
+
+  const changelogCommitsMd = await Promise.all(
+    Object.entries(
+      commitsSinceLatestTag.reduce((prev, curr) => {
+        return {
+          ...prev,
+          [curr.type]: [...(prev[curr.type] ?? []), curr],
+        };
+      }, /** @type {Record<string, import('./index').Commit[]>} */ ({})),
+    )
+      .sort(
+        getSorterFn(([type]) =>
+          [
+            "other",
+            "examples",
+            "docs",
+            "ci",
+            "test",
+            "chore",
+            "refactor",
+            "perf",
+            "fix",
+            "feat",
+          ].indexOf(type),
+        ),
+      )
+      .reverse()
+      .map(async ([type, commits]) => {
+        return Promise.all(
+          commits.map(async (commit) => {
+            let username = "";
+
+            if (ghToken) {
+              const query = commit.author_email;
+
+              const res = await fetch(
+                `https://api.github.com/search/users?q=${query}`,
+                {
+                  headers: {
+                    Authorization: `token ${ghToken}`,
+                  },
+                },
+              );
+              const data = /** @type {unknown} */ (await res.json());
+              if (data && typeof data === "object" && "items" in data) {
+                if (Array.isArray(data.items) && data.items[0]) {
+                  const item = /** @type {object} */ (data.items[0]);
+                  if ("login" in item && typeof item.login === "string") {
+                    username = item.login;
+                  }
+                }
+              }
+            }
+
+            const scope = commit.scope ? `${commit.scope}: ` : "";
+            const subject = commit.subject;
+
+            return `- ${scope}${subject} (${commit.hash}) ${
+              username
+                ? `by @${username}`
+                : `by ${commit.author_name || commit.author_email}`
+            }`;
+          }),
+        ).then((c) => /** @type {const} */ ([type, c]));
+      }),
+  ).then((groups) => {
+    return groups
+      .map(([type, commits]) => {
+        return [`### ${capitalize(type)}`, commits.join("\n")].join("\n\n");
+      })
+      .join("\n\n");
+  });
+
+  const date = new Intl.DateTimeFormat(undefined, {
+    dateStyle: "short",
+    timeStyle: "short",
+  }).format(Date.now());
+
+  const changelogMd = [
+    `Version ${version} - ${date}${tag ? " (Manual Release)" : ""}`,
+    "## Changes",
+    changelogCommitsMd || "- None",
+    "## Packages",
+    changedPackages.map((d) => `- ${d.name}@${version}`).join("\n"),
+  ].join("\n\n");
+
+  console.info("Generating changelog...");
+  console.info();
+  console.info(changelogMd);
+  console.info();
+
+  if (changedPackages.length === 0) {
+    console.info("No packages have been affected.");
+    return;
+  }
+
+  if (!process.env.CI) {
+    console.warn(
+      `This is a dry run for version ${version}. Push to CI to publish for real or set CI=true to override!`,
+    );
+    return;
+  }
+
+  console.info(`Updating all changed packages to version ${version}...`);
+  // Update each package to the new version
+  for (const pkg of changedPackages) {
+    console.info(`  Updating ${pkg.name} version to ${version}...`);
+
+    await updatePackageJson(
+      path.resolve(rootDir, pkg.packageDir, "package.json"),
+      (config) => {
+        config.version = version;
+      },
+    );
+  }
+
+  console.info();
+  console.info(`Publishing all packages to npm with tag "${npmTag}"`);
+
+  // Publish each package
+  for (const pkg of changedPackages) {
+    const packageDir = path.join(rootDir, pkg.packageDir);
+
+    const cmd = `cd ${packageDir} && pnpm publish --tag ${npmTag} --access=public --no-git-checks`;
+    console.info(`  Publishing ${pkg.name}@${version} to npm...`);
+    execSync(cmd, {
+      // @ts-ignore
+      stdio: [process.stdin, process.stdout, process.stderr],
+    });
+  }
+
+  console.info();
+  console.info("Committing changes...");
+  //execSync(`git add -A && git commit -m "${releaseCommitMsg(version)}"`);
+  execSync(
+    `git add -A && git reset -- ${changedPackages
+      .map((pkg) => path.resolve(rootDir, pkg.packageDir, "package.json"))
+      .join(" ")}`,
+  );
+  execSync(
+    `git checkout -- ${changedPackages
+      .map((pkg) => path.resolve(rootDir, pkg.packageDir, "package.json"))
+      .join(" ")}`,
+  );
+  execSync(`git commit -m "${releaseCommitMsg(version)}" --allow-empty`);
+  console.info("  Committed Changes.");
+
+  console.info();
+  console.info("Pushing changes...");
+  execSync("git push");
+  console.info("  Changes pushed.");
+
+  console.info();
+  console.info(`Creating new git tag v${version}`);
+  execSync(`git tag -a -m "v${version}" v${version}`);
+
+  console.info();
+  console.info("Pushing tags...");
+  execSync("git push --tags");
+  console.info("  Tags pushed.");
+
+  if (ghToken && isMainBranch) {
+    console.info();
+    console.info("Creating github release...");
+
+    // Stringify the markdown to escape any quotes
+    execSync(
+      `gh release create v${version} ${
+        branchConfig.prerelease ? "--prerelease" : ""
+      } --notes '${changelogMd.replace(/'/g, '"')}'`,
+      { env: { ...process.env, GH_TOKEN: ghToken } },
+    );
+    console.info("  Github release created.");
+  }
+
+  console.info();
+  console.info("All done!");
+};

package/src/publish/utilities.js

@@ -0,0 +1,50 @@
+// @ts-check
+
+import jsonfile from 'jsonfile';
+
+/** @param {string} version */
+export const releaseCommitMsg = (version) => `release: v${version}`;
+
+/** @param {string} str */
+export const capitalize = (str) => {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+};
+
+/**
+ * @param {string} pathName
+ * @returns {Promise<import('type-fest').PackageJson>}
+ */
+export const readPackageJson = async (pathName) => {
+  return await jsonfile.readFile(pathName);
+};
+
+/**
+ * @param {string} pathName
+ * @param {(json: import('type-fest').PackageJson) => Promise<void> | void} transform
+ */
+export const updatePackageJson = async (pathName, transform) => {
+  const json = await readPackageJson(pathName);
+  await transform(json);
+  await jsonfile.writeFile(pathName, json, {
+    spaces: 2,
+  });
+};
+
+/**
+ * @template TItem
+ * @param {((d: TItem) => number)} sorter
+ * @returns {(a: TItem, b: TItem) => number}
+ */
+export const getSorterFn = (sorter) => {
+  return (a, b) => {
+    const sortedA = sorter(a);
+    const sortedB = sorter(b);
+    if (sortedA > sortedB) {
+      return 1;
+    }
+    if (sortedA < sortedB) {
+      return -1;
+    }
+    return 0;
+  };
+};