chore: import upstream snapshot with attribution

.github/changeset-version.js

@@ -0,0 +1,147 @@
+const assert = require("node:assert");
+const fs = require("node:fs");
+const path = require("node:path");
+const { execSync } = require("node:child_process");
+
+// This script is used by the `release.yml` workflow to update the version of the packages being released.
+// The standard step is only to run `changeset version` but this does not update the lockfile.
+// So we also run `pnpm install`, which does this update.
+// This is a workaround until this is handled automatically by `changeset version`.
+// See https://github.com/changesets/changesets/issues/421.
+
+function getPkg(filePath) {
+	return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+function setPkg(filePath, newPkg) {
+	fs.writeFileSync(filePath, `${JSON.stringify(newPkg, null, "\t")}\n`);
+}
+function parseVersion(version) {
+	// Extract `<major>.<minor>.<patch>` from version (could be a constraint)
+	const match = /(\d+)\.(\d+)\.(\d+)/.exec(version);
+	assert(match !== null, `Expected ${version} to be <major>.<minor>.<patch>`);
+	return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])];
+}
+
+const rootPath = path.resolve(__dirname, "..");
+const miniflarePath = path.join(rootPath, "packages/miniflare");
+const miniflarePkgPath = path.join(miniflarePath, "package.json");
+
+function getWorkerdVersion() {
+	const pnpmWorkspacePath = path.join(rootPath, "pnpm-workspace.yaml");
+	const match = /workerd: "(\d+\.\d+\.\d+)"/.exec(
+		fs.readFileSync(pnpmWorkspacePath, "utf8")
+	);
+	assert(match !== null, `Expected ${match[1]} to be <major>.<minor>.<patch>`);
+	return match[1];
+}
+/**
+ * Gets the correct version to bump `miniflare` to, ensuring the minor versions
+ * of `workerd` and `miniflare` match. Minor bumps in changesets will become
+ * patch bumps if the `workerd` version hasn't changed.
+ * See `changeset-version.test.js` for examples.
+ *
+ * @param workerdVersion `workerd` version constraint in `miniflare` package
+ * @param previousVersion `miniflare` version before running `changeset version`
+ * @param version `miniflare` version after running `changeset version`
+ */
+function getNextMiniflareVersion(workerdVersion, previousVersion, version) {
+	const [, workerdMinor] = parseVersion(workerdVersion);
+	const [, , previousPatch] = parseVersion(previousVersion);
+	const [major, minor] = parseVersion(version);
+	if (workerdMinor === minor) {
+		// If the minor versions match already, there's nothing we need to do
+		return version;
+	} else if (workerdMinor > minor) {
+		// If the workerd minor is greater than the miniflare minor,
+		// use the workerd minor and reset patch to 0
+		return `${major}.${workerdMinor}.0`;
+	} else {
+		// Otherwise, if the workerd minor is less than the miniflare minor,
+		// use the workerd minor and bump the patch instead
+		return `${major}.${workerdMinor}.${previousPatch + 1}`;
+	}
+}
+exports.getNextMiniflareVersion = getNextMiniflareVersion;
+
+function main() {
+	// 1. Get `miniflare` version before applying changesets, so we know if the
+	//    minor version was bumped
+	const previousMiniflarePkg = getPkg(miniflarePkgPath);
+	const previousMiniflareVersion = previousMiniflarePkg.version;
+
+	// 2. Run standard `changeset version` command to apply changesets, bump
+	//    versions, and update changelogs
+	console.log("Applying changesets and updating versions...");
+	execSync("pnpm exec changeset version", { stdio: "inherit" });
+
+	// 3. Force `miniflare`'s minor version to be the same as `workerd`
+	console.log("Getting miniflare and workerd versions...");
+	const miniflarePkg = getPkg(miniflarePkgPath);
+	const miniflareVersion = miniflarePkg.version;
+	const workerdVersion = getWorkerdVersion();
+	const nextMiniflareVersion = getNextMiniflareVersion(
+		workerdVersion,
+		previousMiniflareVersion,
+		miniflareVersion
+	);
+	if (nextMiniflareVersion !== miniflareVersion) {
+		// If `changeset version` didn't produce the correct version on its own...
+
+		// ...update `miniflare`'s `package.json` version
+		console.log(`Updating miniflare version to ${nextMiniflareVersion}...`);
+		miniflarePkg.version = nextMiniflareVersion;
+		setPkg(miniflarePkgPath, miniflarePkg);
+
+		const changedPathsBuffer = execSync("git ls-files --modified", {
+			cwd: rootPath,
+		});
+		console.log("Checking modified files...");
+		const changedPaths = changedPathsBuffer.toString().trim().split("\n");
+		for (const relativeChangedPath of changedPaths) {
+			const changedPath = path.resolve(rootPath, relativeChangedPath);
+			const name = path.basename(changedPath);
+			if (name === "package.json") {
+				console.log("Updating dependencies in", changedPath);
+				// ...update `miniflare` version in dependencies of other packages
+				const pkg = getPkg(changedPath);
+				let changed = false;
+				for (const key of [
+					"dependencies",
+					"devDependencies",
+					"peerDependencies",
+					"optionalDependencies",
+				]) {
+					const constraint = pkg[key]?.["miniflare"];
+					if (constraint === undefined) continue;
+					// Don't update `workspace:`-style constraints
+					if (constraint.startsWith("workspace:")) continue;
+					pkg[key]["miniflare"] = nextMiniflareVersion;
+					changed = true;
+				}
+				if (changed) setPkg(changedPath, pkg);
+			} else if (name === "CHANGELOG.md") {
+				console.log("Updating changelog in", changedPath);
+				// ...update `CHANGELOG.md`s with correct version
+				let changelog = fs.readFileSync(changedPath, "utf8");
+				// Replace version header in `miniflare` `CHANGELOG.md`
+				changelog = changelog.replace(
+					`## ${miniflareVersion}`,
+					`## ${nextMiniflareVersion}`
+				);
+				// Replace `Updated dependencies` line in other `CHANGELOG.md`s
+				changelog = changelog.replace(
+					`- miniflare@${miniflareVersion}`,
+					`- miniflare@${nextMiniflareVersion}`
+				);
+				fs.writeFileSync(changedPath, changelog);
+			}
+		}
+	}
+
+	// 4. Update the lockfile
+	console.log("Updating lockfile...");
+	execSync("pnpm install --lockfile-only", { stdio: "inherit" });
+	console.log("Done.");
+}
+
+if (require.main === module) main();