Introduce version package that incapsulates all the logic for getting CLI version

Author: volodymyrZotov

package.json

@@ -38,13 +38,15 @@
 	"dependencies": {
 		"@actions/core": "^1.11.1",
 		"@actions/tool-cache": "^2.0.2",
-		"cheerio": "^1.1.0"
+		"cheerio": "^1.1.0",
+		"semver": "^7.7.2"
 	},
 	"devDependencies": {
 		"@1password/eslint-config": "^8.1.0",
 		"@1password/prettier-config": "^1.2.0",
 		"@types/jest": "^30.0.0",
 		"@types/node": "^24.0.14",
+		"@types/semver": "^7.7.0",
 		"@vercel/ncc": "^0.38.3",
 		"husky": "^9.1.7",
 		"jest": "^30.0.4",

src/index.ts

@@ -1,95 +1,28 @@
-import * as https from "https";
 import * as core from "@actions/core";
-import * as cheerio from "cheerio";
 import {
 	type Installer,
 	RunnerOS,
 	LinuxInstaller,
 	MacOSInstaller,
 	WindowsInstaller,
 } from "./cli-installer";
-
-export enum VersionType {
-	Latest = "latest",
-	LatestBeta = "latest-beta",
-}
-
-// Returns `true` if the versionType is one of the defined in VersionType enum, otherwise `false`.
-const isValidVersionType = (versionType: string): boolean =>
-	Object.values(VersionType).some((v) => v === versionType);
-
-// Loads the HTML content from the 1Password CLI product history page.
-export const loadHtml = (): Promise<string> => {
-	return new Promise((resolve, reject) => {
-		https
-			.get("https://app-updates.agilebits.com/product_history/CLI2", (res) => {
-				let data = "";
-				res.on("data", (chunk) => (data += chunk));
-				res.on("end", () => {
-					core.debug("HTML loaded successfully");
-					resolve(data)
-				});
-			})
-			.on("error", (e) => {
-				core.error(`Failed to load HTML: ${e.message}`);
-				reject();
-			});
-	});
-};
-
-// Returns the latest version of the 1Password CLI based on the specified channel.
-export const getLatestVersion = async (channel: VersionType): Promise<string> => {
-	core.debug(`Getting ${channel} version`);
-	const html = await loadHtml();
-	const $ = cheerio.load(html);
-	const versions: string[] = [];
-	$("h3").each((_, el) => {
-		const text = $(el).text().trim();
-		const match = text.match(/^([\d.]+(?:-beta\d+)?)/);
-		if (match) {
-			const version = match[1];
-			if (!version) {
-				return
-			}
-			if (
-				(channel === VersionType.Latest && !version.includes("-beta")) ||
-				(channel === VersionType.LatestBeta && version.includes("-beta"))
-			) {
-				versions.push(version);
-			}
-		}
-	});
-
-	if (versions.length === 0) {
-		core.error(`No ${channel} versions found`);
-		throw new Error(`No ${channel} versions found`);
-	}
-
-	return versions[0]!;
-};
+import { VersionResolver } from "./version";
 
 async function run(): Promise<void> {
 	try {
-		const versionType = core.getInput("version") as VersionType;
-		// validate the version input. Should be one of the VersionTypes.
-		if (!isValidVersionType(versionType)) {
-			core.setFailed(
-				`Invalid version input: ${versionType}. Valid options are: ${Object.values(VersionType).join(", ")}. Defaulting to 'latest'.`,
-			);
-			return;
-		}
+		const versionResolver = new VersionResolver(core.getInput("version"));
+		await versionResolver.resolve();
 
-		const version = await getLatestVersion(versionType);
 		let installer: Installer;
 		switch (process.env.RUNNER_OS) {
 			case RunnerOS.Linux:
-				installer = new LinuxInstaller(version);
+				installer = new LinuxInstaller(versionResolver.get());
 				break;
 			case RunnerOS.MacOS:
-				installer = new MacOSInstaller(version);
+				installer = new MacOSInstaller(versionResolver.get());
 				break;
 			case RunnerOS.Windows:
-				installer = new WindowsInstaller(version);
+				installer = new WindowsInstaller(versionResolver.get());
 				break;
 			default:
 				core.setFailed(`Unsupported platform: ${process.env.RUNNER_OS}`);

src/version/constants.ts

@@ -0,0 +1,4 @@
+export enum ReleaseChannel {
+	Stable = "latest",
+	Beta = "latest-beta",
+}

src/version/helper.test.ts

@@ -0,0 +1,59 @@
+import { getLatestVersion } from "./helper";
+import * as helper from "./helper";
+import { ReleaseChannel } from "./constants";
+
+describe("getLatestVersion", () => {
+	afterEach(() => {
+		jest.restoreAllMocks();
+	});
+
+	it("returns latest stable version", async () => {
+		jest.spyOn(helper, "loadHtml").mockResolvedValue(`
+      <html><body>
+        <article><h3> 2.31.1 </h3><span>build number and release date</span></article>
+        <article><h3> 2.32.1 </h3><span>build number and release date</span></article>
+        <article><h3> 2.33.2 </h3><span>build number and release date</span></article>
+        <article><h3>2.33.1 </h3><span>build number and release date</span></article>
+      </body></html>
+    `);
+		const version = await getLatestVersion(ReleaseChannel.Stable);
+		expect(version).toBe("2.33.2");
+	});
+
+	it("returns latest beta version", async () => {
+		jest.spyOn(helper, "loadHtml").mockResolvedValue(`
+      <html><body>
+        <article class="beta"><h3> 1.32.0-beta.01 <span>build number and release date</span></h3></article>
+        <article class="beta"><h3>2.32.0-beta.01 <span>build number and release date</span></h3></article>
+        <article class="beta"><h3>3.32.0-beta.02<span>build number and release date</span></h3></article>
+        <article class="beta"><h3>3.32.0-beta.01 <span>build number and release date</span></h3></article>
+      </body></html>
+    `);
+		const version = await getLatestVersion(ReleaseChannel.Beta);
+		expect(version).toBe("3.32.0-beta.02");
+	});
+
+	it("throws error when no versions found", async () => {
+		jest.spyOn(helper, "loadHtml").mockResolvedValue("<html></html>");
+		await expect(getLatestVersion(ReleaseChannel.Stable)).rejects.toThrow(
+			`No ${ReleaseChannel.Stable} versions found`,
+		);
+	});
+
+	it("throws error when HTML is invalid", async () => {
+		jest
+			.spyOn(helper, "loadHtml")
+			.mockResolvedValue("<html><article></article></html>");
+		await expect(getLatestVersion(ReleaseChannel.Stable)).rejects.toThrow(
+			`No ${ReleaseChannel.Stable} versions found`,
+		);
+	});
+
+	it("calls loadHtml once", async () => {
+		const spy = jest.spyOn(helper, "loadHtml").mockResolvedValue(`
+      <article><h3>2.31.1</h3></article>
+    `);
+		await getLatestVersion(ReleaseChannel.Stable);
+		expect(spy).toHaveBeenCalledTimes(1);
+	});
+});

src/version/helper.ts

@@ -0,0 +1,72 @@
+import * as https from "https";
+import * as core from "@actions/core";
+import * as cheerio from "cheerio";
+import semver from "semver";
+import { ReleaseChannel } from "./constants";
+
+// Loads the HTML content from the 1Password CLI product history page.
+export const loadHtml = (): Promise<string> => {
+	return new Promise((resolve, reject) => {
+		https
+			.get("https://app-updates.agilebits.com/product_history/CLI2", (res) => {
+				let data = "";
+				res.on("data", (chunk) => (data += chunk));
+				res.on("end", () => {
+					core.debug("HTML loaded successfully");
+					resolve(data);
+				});
+			})
+			.on("error", (e) => {
+				core.error(`Failed to load HTML: ${e.message}`);
+				reject();
+			});
+	});
+};
+
+// Finds and returns an array of version strings from the HTML content based on the provided query.
+// Version stored in the first <h3> element of each article element.
+const findVersions = ($: cheerio.CheerioAPI, query: string): string[] => {
+	const versions: string[] = [];
+	$(query).each((_, article) => {
+		const h3 = $(article).find("h3").first();
+		const version = h3
+			.contents()
+			.filter((_, el) => el.type === "text") // select only text nodes
+			.text()
+			.trim();
+		if (version) {
+			versions.push(version);
+		}
+	});
+	return versions;
+};
+
+export const normalizeBetaForSemver = (version: string): string =>
+	version.replace(/-beta\.0*(\d+)/, "-beta.$1");
+
+// Returns the latest version of the 1Password CLI based on the specified channel.
+export const getLatestVersion = async (
+	versionType: ReleaseChannel,
+): Promise<string> => {
+	core.debug(`Getting ${versionType} version`);
+	const html = await loadHtml();
+	const $ = cheerio.load(html);
+	const versions =
+		versionType === ReleaseChannel.Beta
+			? findVersions($, "article.beta")
+			: findVersions($, "article");
+
+	if (versions.length === 0) {
+		core.error(`No ${versionType} versions found`);
+		throw new Error(`No ${versionType} versions found`);
+	}
+
+	// Sort versions in descending order
+	versions.sort((a: string, b: string): number => {
+		const aNorm = new semver.SemVer(normalizeBetaForSemver(a));
+		const bNorm = new semver.SemVer(normalizeBetaForSemver(b));
+		return semver.rcompare(aNorm, bNorm);
+	});
+
+	return versions[0]!;
+};

src/version/index.ts

@@ -0,0 +1 @@
+export { VersionResolver } from "./version-resolver";

src/version/validate.test.ts

@@ -0,0 +1,40 @@
+import { validateVersion } from "./validate";
+import { describe, it, expect } from "@jest/globals";
+
+describe("validateVersion", () => {
+	it('should not throw for "latest"', () => {
+		expect(() => validateVersion("latest")).not.toThrow();
+	});
+
+	it('should not throw for "latest-beta"', () => {
+		expect(() => validateVersion("latest-beta")).not.toThrow();
+	});
+
+	it('should not throw for valid semver version "2.18.0"', () => {
+		expect(() => validateVersion("2.18.0")).not.toThrow();
+	});
+
+	it('should throw for partial version "2"', () => {
+		expect(() => validateVersion("2")).toThrow();
+	});
+
+	it('should throw for partial version "2.1"', () => {
+		expect(() => validateVersion("2.1")).toThrow();
+	});
+
+	it('should not throw for valid beta "2.19.0-beta.01"', () => {
+		expect(() => validateVersion("2.19.0-beta.01")).not.toThrow();
+	});
+
+	it('should not throw for coerced version "v2.19.0"', () => {
+		expect(() => validateVersion("v2.19.0")).not.toThrow();
+	});
+
+	it('should throw for invalid version "latest-abc"', () => {
+		expect(() => validateVersion("latest-abc")).toThrow();
+	});
+
+	it("should throw for empty string", () => {
+		expect(() => validateVersion("")).toThrow();
+	});
+});

src/version/validate.ts

@@ -0,0 +1,23 @@
+import semver from "semver";
+import { ReleaseChannel } from "./constants";
+import {normalizeBetaForSemver} from "./helper";
+
+// Validates if the provided version type is a valid enum value or a valid semver version.
+export const validateVersion = (input: string): void => {
+	if (Object.values(ReleaseChannel).includes(input as ReleaseChannel)) {
+		return;
+	}
+
+	// 1Password beta releases (aka 2.19.0-beta.01) are not semver compliant.
+	// According to semver, it should be "2.19.0-beta.1".
+	// That's why we need to normalize them before validating.
+	// Accepts valid semver versions like "2.18.0" or beta-releases like "2.19.0-beta.01"
+	// or versions with 'v' prefix like "v2.19.0"
+	const normalized = normalizeBetaForSemver(input)
+	const normInput = new semver.SemVer(normalized)
+	if (semver.valid(normInput)) {
+		return;
+	}
+
+	throw new Error(`Invalid version input: ${input}`);
+};

src/version/version-resolver.test.ts

@@ -0,0 +1,57 @@
+import { VersionResolver } from "./version-resolver";
+import { ReleaseChannel } from "./constants";
+import { expect } from "@jest/globals";
+
+describe("VersionResolver", () => {
+	test("should throw error when invalid version provided", async () => {
+		expect(() => new VersionResolver("vv")).toThrow();
+	});
+
+	test("should throw error when version is empty", () => {
+		expect(() => new VersionResolver("")).toThrow();
+	});
+
+	test("should throw error for major version only", async () => {
+		expect(() => new VersionResolver("1")).toThrow();
+	});
+
+	test("should throw error for major and minor version only", async () => {
+		expect(() => new VersionResolver("1.0")).toThrow();
+	});
+
+	test("should resolve latest stable version", async () => {
+		const versionResolver = new VersionResolver(ReleaseChannel.Stable);
+		await versionResolver.resolve();
+		expect(versionResolver.get()).toBeDefined();
+	});
+
+	test("should resolve latest beta version", async () => {
+		const versionResolver = new VersionResolver(ReleaseChannel.Beta);
+		await versionResolver.resolve();
+		expect(versionResolver.get()).toBeDefined();
+	});
+
+	test("should resolve version without 'v' prefix", async () => {
+		const versionResolver = new VersionResolver("1.0.0");
+		await versionResolver.resolve();
+		expect(versionResolver.get()).toBe("v1.0.0");
+	});
+
+	test("should resolve version with 'v' prefix", async () => {
+		const versionResolver = new VersionResolver("v1.0.0");
+		await versionResolver.resolve();
+		expect(versionResolver.get()).toBe("v1.0.0");
+	});
+
+	test("should resolve beta version without 'v' prefix", async () => {
+		const versionResolver = new VersionResolver("2.19.0-beta.01");
+		await versionResolver.resolve();
+		expect(versionResolver.get()).toBe("v2.19.0-beta.01");
+	});
+
+	test("should resolve beta version with 'v' prefix", async () => {
+		const versionResolver = new VersionResolver("v2.19.0-beta.01");
+		await versionResolver.resolve();
+		expect(versionResolver.get()).toBe("v2.19.0-beta.01");
+	});
+});