Using Azure Functions to Create a Changeset Bot

🦋  What kind of change is this for codegarden? (current version is 0.1.0) …
❯ patch
  minor
  major

brew tap azure/functions && brew install azure-functions-core-tools@4

mkdir azure-changeset-bot && git init

.
├── changeset-check
│   ├── function.json
│   ├── index.ts
│   └── sample.dat
├── host.json
├── local.settings.json
├── package-lock.json
├── package.json
└── tsconfig.json

rm -rf node_modules && yarn import && yarn && rm -rf package-lock.json

{
	"version": "2.0.0",
	"tasks": [
		{
			"type": "func",
			"label": "func: host start",
			"command": "host start",
			"problemMatcher": "$func-node-watch",
			"isBackground": true,
			"dependsOn": "yarn build (functions)"
		},
		{
			"type": "shell",
			"label": "yarn build (functions)",
			"command": "yarn run build",
			"dependsOn": "yarn install (functions)",
			"problemMatcher": "$tsc"
		},
		{
			"type": "shell",
			"label": "yarn install (functions)",
			"command": "yarn install"
		},
		{
			"type": "shell",
			"label": "yarn prune (functions)",\
			"command": "yarn prune --production",
			"dependsOn": "yarn build (functions)",
			"problemMatcher": []
		}
	]
}

{
	"azureFunctions.deploySubpath": ".",
	"azureFunctions.postDeployTask": "yarn install (functions)",
	"azureFunctions.projectLanguage": "TypeScript",
	"azureFunctions.projectRuntime": "~4",
	"debug.internalConsoleOptions": "neverOpen",
	"azureFunctions.preDeployTask": "yarn prune (functions)"
}

yarn watch

yarn add azure-devops-node-api dotenv

AZURE_PAT="<YOUR_TOKEN>"

touch utilities.ts

function getEnv(name: string): string {
	const val = process.env[name];
	if (!val) {
		console.error(`${name} env var not set`);
		process.exit(1);
	}
	return val;
}

import * as az from 'azure-devops-node-api';
import * as lc from 'azure-devops-node-api/interfaces/LocationsInterfaces';
 
function getEnv(name: string): string {
	const val = process.env[name];
	if (!val) {
		console.error(`${name} env var not set`);
		process.exit(1);
	}
	return val;
}
 
export async function getApi(baseUrl: string): Promise<az.WebApi> {
	return new Promise<az.WebApi>(async (resolve, reject) => {
		try {
			const token = getEnv("AZURE_PAT");
			const authHandler = az.getPersonalAccessTokenHandler(token);
			const api: az.WebApi = new az.WebApi(baseUrl, authHandler);
			const connectionData: lc.ConnectionData = await vsts.connect();
			
			resolve(api);
		} catch (e) {
			reject(e);
		}
	})
}

import * as az from 'azure-devops-node-api';
import * as lc from 'azure-devops-node-api/interfaces/LocationsInterfaces';
 
function getEnv(name: string): string {
	const val = process.env[name];
	if (!val) {
		console.error(`${name} env var not set`);
		process.exit(1);
	}
	return val;
}
 
export async function getApi(baseUrl: string): Promise<az.WebApi> {
	return new Promise<az.WebApi>(async (resolve, reject) => {
		try {
			const token = getEnv("AZURE_PAT");
			const authHandler = az.getPersonalAccessTokenHandler(token);
			const api: az.WebApi = new az.WebApi(baseUrl, authHandler);
			const connectionData: lc.ConnectionData = await vsts.connect();
			
			resolve(api);
		} catch (e) {
			reject(e);
		}
	})
}
 
export async function getWebApi(baseUrl?: string): Promise<az.WebApi> {
	baseUrl = baseUrl || getEnv("API_URL");
	return await getApi(baseUrl);
}

import { AzureFunction, Context, HttpRequest } from "@azure/functions"
 
const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
	context.log('HTTP trigger function processed a request.');
	
	const name = (req.query.name || (req.body && req.body.name));
	const responseMessage = name
		? "Hello, " + name + ". This HTTP triggered function executed successfully."
		: "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.";
	
	context.res = {
		// status: 200, /* Defaults to 200 */
		body: responseMessage
	};
};
 
export default httpTrigger;

{
	"resource": {
		"pullRequestId": "<ID>",
		"repository": {
			"id": "<REPO_ID>",
			"project": {
				"id": "<PROJECT_ID>",
			}
		},
		"organization": {
			"id": "<ORG_ID>"
		}
	}
}

import { AzureFunction, Context, HttpRequest } from "@azure/functions"
import { WebApi } from "azure-devops-node-api";
 
import * as dotenv from "dotenv";
import * as utils from "../utils"; // or wherever you put your utility functions
 
// read in our environment variables
dotenv.config();
 
const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
	const organization = req.body.resource.organization.id;
	const repository = req.body.resource.repository.id;
	const project = req.body.resource.repository.project.id;
	const pullRequestId = req.body.resource.pullRequestId;
 
	const webApi: WebApi = await utils.getWebApi(
		`https://dev.azure.com/${organization}`
	);
};
 
export default httpTrigger;

import { AzureFunction, Context, HttpRequest } from "@azure/functions"
import { WebApi } from "azure-devops-node-api";
import { IGitApi, GitPullRequest } from "azure-devops-node-api/interfaces/GitInterfaces";
 
import * as dotenv from "dotenv";
import * as utils from "../utils"; // or wherever you put your utility functions
 
// read in our environment variables
dotenv.config();
 
const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
	const organization = req.body.resource.organization.id;
	const repository = req.body.resource.repository.id;
	const project = req.body.resource.repository.project.id;
	const pullRequestId = req.body.resource.pullRequestId;
 
	const webApi: WebApi = await utils.getWebApi(
		`https://dev.azure.com/${organization}`
	);
 
	const gitApi: IGitApi = await webApi.getGitApi();
 
	const pullRequest: GitPullRequest = await gitApi.getPullRequest(
		repository,
		pullRequestId,
		project,
		undefined,
		undefined,
		undefined,
		true
	);
 
	// TODO: Use the Bot to Perform the Checks
};
 
export default httpTrigger;

import { IGitApi } from "azure-devops-node-api/GitApi";
import { GitPullRequest } from "azure-devops-node-api/interfaces/GitInterfaces";
 
export default class ChangeBot {
	private api: IGitApi;
	private pr: GitPullRequest;
	
	constructor(api: IGitApi, pr: GitPullRequest) {
		this.api = api;
		this.pr = pr;
	}
}

import { IGitApi } from "azure-devops-node-api/GitApi";
import { GitPullRequest } from "azure-devops-node-api/interfaces/GitInterfaces";
 
export type ChangebotResult = {
	passed: boolean;
	threads: number[];
}
 
export default class ChangeBot {
	private api: IGitApi;
	private pr: GitPullRequest;
	
	constructor(api: IGitApi, pr: GitPullRequest) {
		this.api = api;
		this.pr = pr;
	}
 
	/**
	 * Performs two tasks:
	 * 1. Check that there is at least 1 changeset file
	 * 2. Generates the changelog if the changeset is not empty
	 * @returns `{ passed: true, threads: [...]}`
	 */
	public async check(): Promise<ChangebotResult> {
		// Step 1 -- Are there Changesets?
		// Step 2 -- Create a new Changelog
	}
}

import { IGitApi } from "azure-devops-node-api/GitApi";
import { GitPullRequest } from "azure-devops-node-api/interfaces/GitInterfaces";
 
type Result = {
	passed: boolean;
	threadId?: number;
}
 
export type ChangebotResult = {
	passed: boolean;
	threads: number[];
}
 
export default class ChangeBot {
	private api: IGitApi;
	private pr: GitPullRequest;
	
	constructor(api: IGitApi, pr: GitPullRequest) {
		this.api = api;
		this.pr = pr;
	}
 
	/**
	 * Performs two tasks:
	 * 1. Check that there is at least 1 changeset file
	 * 2. Generates the changelog if the changeset is not empty
	 * @returns `{ passed: true, threads: [...]}`
	 */
	public async check(): Promise<ChangebotResult> {
		// Step 1 -- Are there Changesets?
		const hasChangeset = await this.hasChangeset();
		// Step 2 -- Create a new Changelog
	}
 
	/**
	 * Checks the repository associated with the Pull Request 
	 * for changesets.
	 * 
	 * @returns `{ passed: true, threadId: <id>}` if passed, passed: false otherwise.
	 */
	private async hasChangeset(): Promise<Result> {
	}
}

/**
 * Create a list of all changed files
 */
private async updateFiles(): Promise<Result> {
	for (const c of this.pr.commits) {
		const changes: GitChange[] = (
			await this.api.getChanges(c.commitId, this.pr.repository.id)
		).changes;
		this.files.push(...changes.map((f) => f.item?.path));
	}
}

import { IGitApi } from "azure-devops-node-api/GitApi";
import { 
	GitChange, 
	GitPullRequest 
} from "azure-devops-node-api/interfaces/GitInterfaces";

export default class Changebot {
	// ...
	// .
	// .
 
	/**
	 * Checks the repository associated with the Pull Request 
	 * for changesets.
	 * 
	 * @returns `{ passed: true, threadId: <id>}` if passed, passed: false otherwise.
	 */
	private async hasChangeset(): Promise<Result> {
		await this.updateFiles();
	
		const changesetFiles = this.files
			.filter((f) => f.includes("/.changeset"))
			.map((f) => f.replace("/.changeset/", ""));
	
		// find the unique files
		const changesets = Array.from(
			new Set(
				changesetFiles
					.filter((f) => f.split("-").length == 3 ))
					.values()
			)
		);
	
		const passed = changesets.length > 0;
	}
}

export default class Changebot {
	// ...
	// .
	// .
 
	/**
	 * Checks the repository associated with the Pull Request 
	 * for changesets.
	 * 
	 * @returns `{ passed: true, threadId: <id>}` if passed, passed: false otherwise.
	 */
	private async hasChangeset(): Promise<Result> {
		await this.updateFiles();
	
		const changesetFiles = this.files
			.filter((f) => f.includes("/.changeset"))
			.map((f) => f.replace("/.changeset/", ""));
	
		// find the unique files
		const changesets = Array.from(
			new Set(
				changesetFiles
					.filter((f) => f.split("-").length == 3 ))
					.values()
			)
		);
	
		const passed = changesets.length > 0;
 
		let title = "";
		let description = "";
		const footer = 
			"> ChangeBot looks at Pull Requests to find files generated by [@changesets/cli](https://github.com/changesets/changesets). If you feel like there is an issue, you can override the branch policy requirements, but proceed with caution.";
 
		if (passed) {
			title = "# Changeset Check Passed ✅\n";
			description = "Changebot was able to find the following changeset(s):\n";
			description += changesets.map((r) => `- \`${r}\`\n`).join("");
		} else {
			title = "# Changeset Check Failed ❌\n";
			description = "Changeset Bot was unable to find changeset files, and detected changes to source code in the PR.\nPlease commit your changeset to the PR to pass this check.\n";
		}
 
		const content = [title, description, footer].join("");
 
		const thread = await this.threads.upsertThread(
			content,
			(t) => 
				t?.comments?.find((c) => c?.content?.includes('# Changeset Check')) != null
		);
 
		passed
			? this.threads.setThreadStatus(thread, CommentThreadStatus.Closed)
			: this.threads.setThreadStatus(thread, CommentThreadStatus.Active);
		
		return {
			passed: passed,
			threadId: thread.id
		}
	}
}

import { IGitApi } from "azure-devops-node-api/GitApi";
import {
	CommentThreadStatus,
	GitChange, 
	GitPullRequest 
} from "azure-devops-node-api/interfaces/GitInterfaces";

import { IGitApi } from "azure-devops-node-api/GitApi";
import { GitPullRequest } from "azure-devops-node-api/interfaces/GitInterfaces";
 
export default class ThreadManager {
	private api: IGitApi;
	private pr: GitPullRequest;
 
	constructor(api: IGitApi, pr: GitPullRequest) {
		this.api = api;
		this.pr = pr;
	}
}

export default class Changebot {
	// ...
	// .
	// .
 
	/**
	 * Generate a changelog entry for the given changes.
	 */
	private async generateChangelog(): Promise<Result> {
	}
}

yarn add \
	@changesets/apply-release-plan \
	@changesets/config \
	@changesets/get-release-plan \
	@changesets/pre \
	@changesets/read \
	@changesets/types \
	@manypkg/get-packages \
	fs-extra \
	mdast-util-to-string@^1.0.6 \
	remark-parse@^7.0.1 \
	remark-stringify@^7.0.3 \
	unified@^8.3.2

/**
 * Semantic "Bump" Versions
 */
export const ChangesetBumpLevels = {
	dep: 0,
	patch: 1,
	minor: 2,
	major: 3,
} as const;
 
/**
 * Get the changelog entry for the given verison of the package.
 *
 * @param changelog changelog content to parse through
 * @param version version to get entry for
 * @returns changelog entry for the given version
 */
export async function getChangelogEntry(changelog: string, version: string) {
	let ast = unified().use(remarkParse).parse(changelog);
	let highestLevel: number = ChangesetBumpLevels.dep;
	// @ts-ignore
	let nodes = ast.children as Array<any>;
	let headingStartInfo:
		| {
			index: number;
			depth: number;
		   }
		| undefined;
	let endIndex: number | undefined;
	for (let i = 0; i < nodes.length; i++) {
		let node = nodes[i];
		if (node.type === "heading") {
			let stringified: string = mdastToString(node);
			let match = stringified.toLowerCase().match(/(major|minor|patch)/);
			if (match !== null) {
				let level =
					ChangesetBumpLevels[match[0] as "major" | "minor" | "patch"];
				highestLevel = Math.max(level, highestLevel);
			}
			if (headingStartInfo === undefined && stringified === version) {
				headingStartInfo = {
					index: i,
					depth: node.depth,
				};
				continue;
			}
			if (
				endIndex === undefined &&
				headingStartInfo !== undefined &&
				headingStartInfo.depth === node.depth
			) {
				endIndex = i;
				break;
			}
		}
	}
	if (headingStartInfo) {
		// @ts-ignore
		ast.children = (ast.children as any).slice(
			headingStartInfo.index + 1,
			endIndex
		);
	}
	return {
		content: unified().use(remarkStringify).stringify(ast),
		highestLevel: highestLevel,
	};
}

import { CommitResult, PushResult } from 'simple-git';
import getChangesets from "@changesets/read";
import getReleasePlan from "@changesets/get-release-plan";
import { getPackages } from "@manypkg/get-packages";
import { getChangelogEntry } from "../utils";
import { join } from "path";
import fs from "fs-extra";
import * as child_process from "child_process";
import { promisify } from "util";
 
const exec = promisify(child_process.exec);
 
export default class Changebot {
	// ...
	// .
	// .
 
	/**
	 * Generate a changelog entry for the given changes.
	 */
	private async generateChangelog(): Promise<Result> {
		const files = ["CHANGELOG.md", "package.json"];
 
		await this.git.checkout();
		const changesets = await getChangesets(this.git.dir);
		const releasePlan = await getReleasePlan(this.git.dir, "main");
		const packages = await getPackages(this.get.dir);
		const config = await read(this.git.dir, packages);
		
		await applyReleasePlan(releasePlan, packages, config);
		
		files.push(...changesets.map((c) => `.changeset/${c.id}.md`));
		await this.git.add(files);
		
		const commit: CommitResult = await this.git.commit(
			"chore(changelog): generate changelog"
		);
		const push: PushResult = await this.git.push();
		
		const pkg = require(join(this.git.dir, "package.json"));
		const changelog = await fs.readFile(
			join(this.git.dir, "CHANGELOG.md"),
			"utf-8"
		);
		const contents = await getChangelogEntry(changelog, pkg.version);
	}
}

export default class Changebot {
	// ...
	// .
	// .
 
	/**
	 * Performs two tasks:
	 * 1. Check that there is at least 1 changeset file
	 * 2. Generates the changelog if the changeset is not empty
	 * @returns `{ passed: true, threads: [...]}`
	 */
	public async check(): Promise<ChangebotResult> {
		// Step 1 -- Are there Changesets?
		const hasChangeset = await this.hasChangeset();
		// Step 2 -- Create a new Changelog (if Step 1 passes)
		if (hasChangeset.passed) {
			await this.git.initialize(this.pr);
			const createdChangelog = await this.generateChangelog();
			return {
				passed: hasChangeset.passed && createdChangelog.passed,
				threads: [hasChangeset.threadId, createdChangelog.threadId]
			}
		}
		return {
			passed: hasChangeset.passed,
			threads: [hasChangeset.threadId]
		}
	}
}

import { AzureFunction, Context, HttpRequest } from "@azure/functions"
import { WebApi } from "azure-devops-node-api";
import { IGitApi, GitPullRequest } from "azure-devops-node-api/interfaces/GitInterfaces";
 
import * as dotenv from "dotenv";
import * as utils from "../utils"; // or wherever you put your utility functions
 
// read in our environment variables
dotenv.config();
 
const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
	const organization = req.body.resource.organization.id;
	const repository = req.body.resource.repository.id;
	const project = req.body.resource.repository.project.id;
	const pullRequestId = req.body.resource.pullRequestId;
 
	const webApi: WebApi = await utils.getWebApi(
		`https://dev.azure.com/${organization}`
	);
 
	const gitApi: IGitApi = await webApi.getGitApi();
 
	const pullRequest: GitPullRequest = await gitApi.getPullRequest(
		repository,
		pullRequestId,
		project,
		undefined,
		undefined,
		undefined,
		true
	);
	
	const bot = new ChangeBot(gitApi, pullRequest, utils.getEnv('AZURE_PAT'));;
	const res = await bot.check();
 
	context.res = {
		status: res.passed,
		body: res.threads
	}
};
 
export default httpTrigger;