@pob/version 5.1.0 → 6.0.0

package/src/index.ts

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import { program } from "commander";
+
+import "./commands/version.ts";
+
+// relative to dist directory
+const pkg = JSON.parse(
+  // eslint-disable-next-line unicorn/prefer-json-parse-buffer
+  fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+);
+
+program.name(pkg.name).description(pkg.description).version(pkg.version);
+program.parse();

package/src/missing-types.d.ts

@@ -0,0 +1,10 @@
+// declare module "conventional-changelog-core" {
+//   export default function conventionalChangelogCore(
+//     options: any,
+//     context?: any,
+//     gitRawCommitsOpts?: any,
+//     parserOpts?: any,
+//     writerOpts?: any,
+//     gitRawExecOpts?: any,
+//   ): Readable;
+// }

package/src/pm/BunPackageManager.ts

@@ -0,0 +1,29 @@
+import { execCommand } from "../utils/execCommand.ts";
+import type {
+  PackageManager,
+  PackageManagerPublishOptions,
+} from "./PackageManager.ts";
+
+export const BunPackageManager: PackageManager = {
+  async runScript(workspace, scriptName) {
+    await execCommand(workspace, ["bun", "run", scriptName], "inherit");
+  },
+
+  async publish(workspace, options?: PackageManagerPublishOptions) {
+    if (options?.provenance) {
+      // Use bun pack for provenance support
+      // See: https://github.com/oven-sh/bun/issues/15601
+      const packResult = await execCommand(workspace, ["bun", "pm", "pack"]);
+      // Extract .tgz filename from output (find line ending with .tgz)
+      const lines = packResult.stdout.trim().split("\n");
+      const tgzPath =
+        lines.find((line) => line.endsWith(".tgz")) ?? lines.at(-1);
+      if (!tgzPath) {
+        throw new Error("Failed to extract .tgz path from bun pack output");
+      }
+      await execCommand(workspace, ["npm", "publish", "--provenance", tgzPath]);
+    } else {
+      await execCommand(workspace, ["bun", "publish"], "inherit");
+    }
+  },
+};

package/src/pm/PackageManager.ts

@@ -0,0 +1,90 @@
+import { existsSync } from "node:fs";
+import type { Workspace } from "../utils/packageUtils.ts";
+import { BunPackageManager } from "./BunPackageManager.ts";
+import { PnpmPackageManager } from "./PnpmPackageManager.ts";
+import { YarnPackageManager } from "./YarnPackageManager.ts";
+
+export interface PackageManagerPublishOptions {
+  provenance?: boolean;
+}
+
+export interface PackageManager {
+  installOnPackageContentChange?: (rootWorkspace: Workspace) => Promise<void>;
+  runScript: (workspace: Workspace, scriptName: string) => Promise<void>;
+  publish: (
+    workspace: Workspace,
+    options?: PackageManagerPublishOptions,
+  ) => Promise<void>;
+  publishWorkspaces?: (
+    rootWorkspace: Workspace,
+    options?: PackageManagerPublishOptions,
+  ) => Promise<void>;
+}
+
+export const autoDetectPackageManager = (
+  rootWorkspace: Workspace,
+): PackageManager => {
+  const hasYarnLock = existsSync(`${rootWorkspace.cwd}/yarn.lock`);
+  const hasBunLockLegacy = existsSync(`${rootWorkspace.cwd}/bun.lockb`);
+  const hasBunLock = existsSync(`${rootWorkspace.cwd}/bun.lock`);
+  const hasNpmPackageLock = existsSync(
+    `${rootWorkspace.cwd}/package-lock.json`,
+  );
+  const hasPnpmLock = existsSync(`${rootWorkspace.cwd}/pnpm-lock.yaml`);
+
+  if (
+    [
+      hasYarnLock,
+      hasBunLockLegacy,
+      hasBunLock,
+      hasNpmPackageLock,
+      hasPnpmLock,
+    ].filter(Boolean).length > 1
+  ) {
+    throw new Error(
+      `Multiple lock files detected in workspace at ${rootWorkspace.cwd}. Please ensure only one lock file is present, or pass --package-manager option to bypass auto-detection.`,
+    );
+  }
+
+  if (hasYarnLock) {
+    return YarnPackageManager;
+  }
+
+  if (hasBunLockLegacy || hasBunLock) {
+    return BunPackageManager;
+  }
+
+  if (hasPnpmLock) {
+    return PnpmPackageManager;
+  }
+
+  if (hasNpmPackageLock) {
+    throw new Error(
+      "NPM is not currently supported as a package manager. Please migrate to Yarn or Bun, or open an issue to request support.",
+    );
+  }
+
+  throw new Error(
+    `No lock file detected in workspace at ${rootWorkspace.cwd}. Please ensure a supported lock file is present, or pass --package-manager option to bypass auto-detection.`,
+  );
+};
+
+export const getPackageManager = (
+  rootWorkspace: Workspace,
+  specifiedPackageManager?: "bun" | "pnpm" | "yarn",
+): PackageManager => {
+  switch (specifiedPackageManager) {
+    case "bun":
+      return BunPackageManager;
+    case "yarn":
+      return YarnPackageManager;
+    case "pnpm":
+      return PnpmPackageManager;
+    case undefined:
+    default: {
+      throw new Error(
+        "Invalid package manager specified. Supported values are 'bun' and 'yarn'.",
+      );
+    }
+  }
+};

package/src/pm/PnpmPackageManager.ts

@@ -0,0 +1,23 @@
+import { execCommand } from "../utils/execCommand.ts";
+import type {
+  PackageManager,
+  PackageManagerPublishOptions,
+} from "./PackageManager.ts";
+
+export const PnpmPackageManager: PackageManager = {
+  async runScript(workspace, scriptName) {
+    await execCommand(workspace, ["pnpm", "run", scriptName], "inherit");
+  },
+
+  async publish(workspace, options?: PackageManagerPublishOptions) {
+    if (options?.provenance) {
+      await execCommand(
+        workspace,
+        ["pnpm", "publish", "--provenance"],
+        "inherit",
+      );
+    } else {
+      await execCommand(workspace, ["pnpm", "publish"], "inherit");
+    }
+  },
+};

package/src/pm/YarnPackageManager.ts

@@ -0,0 +1,44 @@
+import { execCommand } from "../utils/execCommand.ts";
+import type { Workspace } from "../utils/packageUtils.ts";
+import type {
+  PackageManager,
+  PackageManagerPublishOptions,
+} from "./PackageManager.ts";
+
+export const YarnPackageManager: PackageManager = {
+  async installOnPackageContentChange(rootWorkspace: Workspace) {
+    await execCommand(rootWorkspace, ["yarn", "install"], "inherit");
+  },
+
+  async runScript(workspace: Workspace, scriptName: string) {
+    await execCommand(workspace, ["yarn", "run", scriptName], "inherit");
+  },
+
+  async publish(workspace: Workspace, options?: PackageManagerPublishOptions) {
+    const publishArgs = ["yarn", "npm", "publish"];
+    if (options?.provenance) {
+      publishArgs.push("--provenance");
+    }
+    await execCommand(workspace, publishArgs, "inherit");
+  },
+
+  async publishWorkspaces(
+    rootWorkspace: Workspace,
+    options?: PackageManagerPublishOptions,
+  ) {
+    const publishArgs = [
+      "yarn",
+      "workspaces",
+      "foreach",
+      "--all",
+      "--parallel",
+      "--no-private",
+      "npm",
+      "publish",
+    ];
+    if (options?.provenance) {
+      publishArgs.push("--provenance");
+    }
+    await execCommand(rootWorkspace, publishArgs, "inherit");
+  },
+};

package/src/utils/UsageError.ts

@@ -0,0 +1,6 @@
+export class UsageError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UsageError";
+  }
+}

package/src/utils/bumpTypeUtils.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { calcBumpRange } from "./bumpTypeUtils.ts";
+import type { Workspace } from "./packageUtils.ts";
+
+const workspace: Workspace = {
+  cwd: "/repo/packages/foo",
+  relativeCwd: "packages/foo",
+  pkg: { name: "foo", version: "1.0.0" },
+};
+
+describe("calcBumpRange", () => {
+  it("keeps bare * unchanged", () => {
+    expect(calcBumpRange(workspace, "*", "2.0.0")).toBe("*");
+  });
+
+  it("keeps workspace:* unchanged", () => {
+    expect(calcBumpRange(workspace, "workspace:*", "2.0.0")).toBe(
+      "workspace:*",
+    );
+  });
+
+  it("keeps workspace:^ unchanged", () => {
+    expect(calcBumpRange(workspace, "workspace:^", "2.0.0")).toBe(
+      "workspace:^",
+    );
+  });
+
+  it("keeps workspace:~ unchanged", () => {
+    expect(calcBumpRange(workspace, "workspace:~", "2.0.0")).toBe(
+      "workspace:~",
+    );
+  });
+
+  it("keeps workspace:<relative path> unchanged", () => {
+    expect(calcBumpRange(workspace, "workspace:packages/foo", "2.0.0")).toBe(
+      "workspace:packages/foo",
+    );
+  });
+
+  it("bumps workspace:^x.y.z ranges", () => {
+    expect(calcBumpRange(workspace, "workspace:^1.0.0", "2.0.0")).toBe(
+      "workspace:^2.0.0",
+    );
+  });
+
+  it("bumps workspace:~x.y.z ranges", () => {
+    expect(calcBumpRange(workspace, "workspace:~1.0.0", "2.0.0")).toBe(
+      "workspace:~2.0.0",
+    );
+  });
+
+  it("bumps plain ^x.y.z ranges", () => {
+    expect(calcBumpRange(workspace, "^1.0.0", "2.0.0")).toBe("^2.0.0");
+  });
+
+  it("bumps exact x.y.z versions", () => {
+    expect(calcBumpRange(workspace, "1.0.0", "2.0.0")).toBe("2.0.0");
+  });
+
+  it("throws on an unsupported range", () => {
+    expect(() => calcBumpRange(workspace, "1.x", "2.0.0")).toThrow(
+      /Couldn't bump range/,
+    );
+  });
+});

package/src/utils/bumpTypeUtils.ts

@@ -0,0 +1,111 @@
+import semver from "semver";
+import { UsageError } from "./UsageError.ts";
+import type { Workspace } from "./packageUtils.ts";
+import { getWorkspaceName } from "./workspaceUtils.ts";
+
+export type BumpType = "major" | "minor" | "patch";
+
+// https://github.com/yarnpkg/berry/blob/506ded5f5f5a89553435940c74f1d857fd685a42/packages/plugin-version/sources/versionUtils.ts#L10
+// Basically we only support auto-upgrading the ranges that are very simple (^x.y.z, ~x.y.z, >=x.y.z, and of course x.y.z)
+const SUPPORTED_UPGRADE_REGEXP =
+  // eslint-disable-next-line regexp/no-unused-capturing-group
+  /^((?:>=|[~^])?)(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-z-][0-9a-z-]*)(\.(0|[1-9]\d*|\d*[a-z-][0-9a-z-]*))*)?(\+[0-9a-z-]+(\.[0-9a-z-]+)*)?$/i;
+
+const yarnWorkspaceProtocol = "workspace:";
+
+export const calcBumpRange = (
+  workspace: Workspace,
+  range: string,
+  newVersion: string,
+): string => {
+  if (range === "*") {
+    return range;
+  }
+
+  let useWorkspaceProtocol = false;
+
+  if (range.startsWith(yarnWorkspaceProtocol)) {
+    const slicedRange = range.slice(yarnWorkspaceProtocol.length);
+
+    // Workspaces referenced through their path never get upgraded ("workspace:packages/yarnpkg-core")
+    if (slicedRange === workspace.relativeCwd) {
+      return range;
+    }
+
+    if (slicedRange === "*" || slicedRange === "^" || slicedRange === "~") {
+      return range;
+    }
+
+    range = slicedRange;
+    useWorkspaceProtocol = true;
+  }
+
+  const parsed = SUPPORTED_UPGRADE_REGEXP.exec(range);
+  if (!parsed) {
+    const workspaceName = getWorkspaceName(workspace);
+    throw new Error(`Couldn't bump range ${range} in ${workspaceName}`);
+  }
+
+  return `${useWorkspaceProtocol ? yarnWorkspaceProtocol : ""}${parsed[1] ?? ""}${newVersion}`;
+};
+
+export const getHighestBumpType = (bumpTypes: BumpType[]): BumpType => {
+  if (bumpTypes.includes("major")) {
+    return "major";
+  }
+
+  if (bumpTypes.includes("minor")) {
+    return "minor";
+  }
+
+  return "patch";
+};
+
+export const calcBumpType = (
+  bumpType: BumpType,
+  maxBumpType: BumpType,
+): BumpType => {
+  if (maxBumpType === "major") {
+    return bumpType;
+  }
+
+  if (maxBumpType === "minor") {
+    return bumpType === "major" || bumpType === "minor" ? "minor" : "patch";
+  }
+
+  return "patch";
+};
+
+const incVersion = (version: string, bumpType: BumpType): string | null => {
+  // handle breaking of 0.x
+  if (bumpType === "major" && semver.major(version) === 0) {
+    bumpType = "minor";
+  }
+  return semver.inc(version, bumpType);
+};
+
+export const incrementVersion = (
+  workspace: Workspace,
+  currentVersion: string,
+  bumpType: BumpType,
+): string => {
+  const newVersion = incVersion(currentVersion, bumpType);
+
+  if (!newVersion) {
+    throw new UsageError(
+      `Could not determine next version for "${getWorkspaceName(
+        workspace,
+      )}" (currentVersion: ${currentVersion}, bumpType: ${bumpType}})`,
+    );
+  }
+
+  return newVersion;
+};
+
+// const createPrerelease = (
+//   version: string,
+//   prereleaseType: ReleaseType,
+//   prereleaseId: string,
+// ) => {
+//   return semver.inc(version, prereleaseType, prereleaseId);
+// };