@paklo/core 0.1.0

package/dist/node/azure.js

@@ -0,0 +1,735 @@
+import "./environment-DX5CD-dD.js";
+import { n as logger } from "./logger-bWnHxtAf.js";
+import { r as isErrorTemporaryFailure, t as HttpRequestError } from "./http-BG_-s47I.js";
+import { P as parseDependabotConfig, c as DependabotExistingGroupPRSchema, j as POSSIBLE_CONFIG_FILE_PATHS, l as DependabotExistingPRSchema } from "./job-Crr4kh3e.js";
+import "./dependabot-BteoKZVy.js";
+import * as path from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+
+//#region src/azure/types.ts
+let VersionControlChangeType = /* @__PURE__ */ function(VersionControlChangeType$1) {
+	VersionControlChangeType$1[VersionControlChangeType$1["None"] = 0] = "None";
+	VersionControlChangeType$1[VersionControlChangeType$1["Add"] = 1] = "Add";
+	VersionControlChangeType$1[VersionControlChangeType$1["Edit"] = 2] = "Edit";
+	VersionControlChangeType$1[VersionControlChangeType$1["Encoding"] = 4] = "Encoding";
+	VersionControlChangeType$1[VersionControlChangeType$1["Rename"] = 8] = "Rename";
+	VersionControlChangeType$1[VersionControlChangeType$1["Delete"] = 16] = "Delete";
+	VersionControlChangeType$1[VersionControlChangeType$1["Undelete"] = 32] = "Undelete";
+	VersionControlChangeType$1[VersionControlChangeType$1["Branch"] = 64] = "Branch";
+	VersionControlChangeType$1[VersionControlChangeType$1["Merge"] = 128] = "Merge";
+	VersionControlChangeType$1[VersionControlChangeType$1["Lock"] = 256] = "Lock";
+	VersionControlChangeType$1[VersionControlChangeType$1["Rollback"] = 512] = "Rollback";
+	VersionControlChangeType$1[VersionControlChangeType$1["SourceRename"] = 1024] = "SourceRename";
+	VersionControlChangeType$1[VersionControlChangeType$1["TargetRename"] = 2048] = "TargetRename";
+	VersionControlChangeType$1[VersionControlChangeType$1["Property"] = 4096] = "Property";
+	VersionControlChangeType$1[VersionControlChangeType$1["All"] = 8191] = "All";
+	return VersionControlChangeType$1;
+}({});
+let GitPullRequestMergeStrategy = /* @__PURE__ */ function(GitPullRequestMergeStrategy$1) {
+	GitPullRequestMergeStrategy$1[GitPullRequestMergeStrategy$1["NoFastForward"] = 1] = "NoFastForward";
+	GitPullRequestMergeStrategy$1[GitPullRequestMergeStrategy$1["Squash"] = 2] = "Squash";
+	GitPullRequestMergeStrategy$1[GitPullRequestMergeStrategy$1["Rebase"] = 3] = "Rebase";
+	GitPullRequestMergeStrategy$1[GitPullRequestMergeStrategy$1["RebaseMerge"] = 4] = "RebaseMerge";
+	return GitPullRequestMergeStrategy$1;
+}({});
+let CommentThreadStatus = /* @__PURE__ */ function(CommentThreadStatus$1) {
+	CommentThreadStatus$1[CommentThreadStatus$1["Unknown"] = 0] = "Unknown";
+	CommentThreadStatus$1[CommentThreadStatus$1["Active"] = 1] = "Active";
+	CommentThreadStatus$1[CommentThreadStatus$1["Fixed"] = 2] = "Fixed";
+	CommentThreadStatus$1[CommentThreadStatus$1["WontFix"] = 3] = "WontFix";
+	CommentThreadStatus$1[CommentThreadStatus$1["Closed"] = 4] = "Closed";
+	CommentThreadStatus$1[CommentThreadStatus$1["ByDesign"] = 5] = "ByDesign";
+	CommentThreadStatus$1[CommentThreadStatus$1["Pending"] = 6] = "Pending";
+	return CommentThreadStatus$1;
+}({});
+let CommentType = /* @__PURE__ */ function(CommentType$1) {
+	CommentType$1[CommentType$1["Unknown"] = 0] = "Unknown";
+	CommentType$1[CommentType$1["Text"] = 1] = "Text";
+	CommentType$1[CommentType$1["CodeChange"] = 2] = "CodeChange";
+	CommentType$1[CommentType$1["System"] = 3] = "System";
+	return CommentType$1;
+}({});
+let ItemContentType = /* @__PURE__ */ function(ItemContentType$1) {
+	ItemContentType$1[ItemContentType$1["RawText"] = 0] = "RawText";
+	ItemContentType$1[ItemContentType$1["Base64Encoded"] = 1] = "Base64Encoded";
+	return ItemContentType$1;
+}({});
+let PullRequestAsyncStatus = /* @__PURE__ */ function(PullRequestAsyncStatus$1) {
+	PullRequestAsyncStatus$1[PullRequestAsyncStatus$1["NotSet"] = 0] = "NotSet";
+	PullRequestAsyncStatus$1[PullRequestAsyncStatus$1["Queued"] = 1] = "Queued";
+	PullRequestAsyncStatus$1[PullRequestAsyncStatus$1["Conflicts"] = 2] = "Conflicts";
+	PullRequestAsyncStatus$1[PullRequestAsyncStatus$1["Succeeded"] = 3] = "Succeeded";
+	PullRequestAsyncStatus$1[PullRequestAsyncStatus$1["RejectedByPolicy"] = 4] = "RejectedByPolicy";
+	PullRequestAsyncStatus$1[PullRequestAsyncStatus$1["Failure"] = 5] = "Failure";
+	return PullRequestAsyncStatus$1;
+}({});
+let PullRequestStatus = /* @__PURE__ */ function(PullRequestStatus$1) {
+	PullRequestStatus$1[PullRequestStatus$1["NotSet"] = 0] = "NotSet";
+	PullRequestStatus$1[PullRequestStatus$1["Active"] = 1] = "Active";
+	PullRequestStatus$1[PullRequestStatus$1["Abandoned"] = 2] = "Abandoned";
+	PullRequestStatus$1[PullRequestStatus$1["Completed"] = 3] = "Completed";
+	PullRequestStatus$1[PullRequestStatus$1["All"] = 4] = "All";
+	return PullRequestStatus$1;
+}({});
+
+//#endregion
+//#region src/azure/models.ts
+/**
+* Pull request property names used to store metadata about the pull request.
+* https://learn.microsoft.com/en-us/rest/api/azure/devops/git/pull-request-properties
+*/
+const DEVOPS_PR_PROPERTY_MICROSOFT_GIT_SOURCE_REF_NAME = "Microsoft.Git.PullRequest.SourceRefName";
+const DEVOPS_PR_PROPERTY_DEPENDABOT_PACKAGE_MANAGER = "Dependabot.PackageManager";
+const DEVOPS_PR_PROPERTY_DEPENDABOT_DEPENDENCIES = "Dependabot.Dependencies";
+
+//#endregion
+//#region src/azure/utils.ts
+function normalizeFilePath(path$1) {
+	return path$1?.replace(/\\/g, "/")?.replace(/^\.\//, "/")?.replace(/^([^/])/, "/$1");
+}
+function normalizeBranchName(branch) {
+	return branch?.replace(/^refs\/heads\//i, "");
+}
+const DependenciesPrPropertySchema = DependabotExistingPRSchema.array().or(DependabotExistingGroupPRSchema);
+function buildPullRequestProperties(packageManager, dependencies) {
+	return [{
+		name: DEVOPS_PR_PROPERTY_DEPENDABOT_PACKAGE_MANAGER,
+		value: packageManager
+	}, {
+		name: DEVOPS_PR_PROPERTY_DEPENDABOT_DEPENDENCIES,
+		value: JSON.stringify(dependencies)
+	}];
+}
+function parsePullRequestProperties(pullRequests, packageManager) {
+	return Object.fromEntries(pullRequests.filter((pr) => {
+		return pr.properties?.find((p) => p.name === DEVOPS_PR_PROPERTY_DEPENDABOT_PACKAGE_MANAGER && (packageManager === null || p.value === packageManager));
+	}).map((pr) => {
+		return [pr.id, DependenciesPrPropertySchema.parse(JSON.parse(pr.properties.find((p) => p.name === DEVOPS_PR_PROPERTY_DEPENDABOT_DEPENDENCIES).value))];
+	}));
+}
+function getPullRequestForDependencyNames(existingPullRequests, packageManager, dependencyNames) {
+	return existingPullRequests.find((pr) => {
+		return pr.properties?.find((p) => p.name === DEVOPS_PR_PROPERTY_DEPENDABOT_PACKAGE_MANAGER && p.value === packageManager) && pr.properties?.find((p) => p.name === DEVOPS_PR_PROPERTY_DEPENDABOT_DEPENDENCIES && areEqual(getDependencyNames(DependenciesPrPropertySchema.parse(JSON.parse(p.value))), dependencyNames));
+	});
+}
+function getDependencyNames(dependencies) {
+	return (Array.isArray(dependencies) ? dependencies : dependencies.dependencies).map((dep) => dep["dependency-name"]?.toString());
+}
+function areEqual(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((name) => b.includes(name));
+}
+function getPullRequestChangedFilesForOutputData(data) {
+	return data["updated-dependency-files"].filter((file) => file.type === "file").map((file) => {
+		let changeType = VersionControlChangeType.None;
+		if (file.deleted === true) changeType = VersionControlChangeType.Delete;
+		else if (file.operation === "update") changeType = VersionControlChangeType.Edit;
+		else changeType = VersionControlChangeType.Add;
+		return {
+			changeType,
+			path: path.join(file.directory, file.name),
+			content: file.content,
+			encoding: file.content_encoding ?? "utf8"
+		};
+	});
+}
+function getPullRequestCloseReasonForOutputData(data) {
+	const leadDependencyName = data["dependency-names"][0];
+	let reason;
+	switch (data.reason) {
+		case "dependencies_changed":
+			reason = `Looks like the dependencies have changed`;
+			break;
+		case "dependency_group_empty":
+			reason = `Looks like the dependencies in this group are now empty`;
+			break;
+		case "dependency_removed":
+			reason = `Looks like ${leadDependencyName} is no longer a dependency`;
+			break;
+		case "up_to_date":
+			reason = `Looks like ${leadDependencyName} is up-to-date now`;
+			break;
+		case "update_no_longer_possible":
+			reason = `Looks like ${leadDependencyName} can no longer be updated`;
+			break;
+	}
+	if (reason && reason.length > 0) reason += ", so this is no longer needed.";
+	return reason;
+}
+function getPullRequestDependenciesPropertyValueForOutputData(data) {
+	const dependencies = data.dependencies?.map((dep) => {
+		return {
+			"dependency-name": dep.name,
+			"dependency-version": dep.version,
+			directory: dep.directory
+		};
+	});
+	const dependencyGroupName = data["dependency-group"]?.name;
+	if (!dependencyGroupName) return dependencies;
+	return {
+		"dependency-group-name": dependencyGroupName,
+		dependencies
+	};
+}
+function getPullRequestDescription(packageManager, body, dependencies) {
+	let header = "";
+	const footer = "";
+	const description = (body || "").replace(new RegExp(decodeURIComponent("%EF%BF%BD%EF%BF%BD%EF%BF%BD"), "g"), "");
+	if (dependencies.length === 1) {
+		const compatibilityScoreBadges = dependencies.map((dep) => {
+			return `![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=${dep.name}&package-manager=${packageManager}&previous-version=${dep["previous-version"]}&new-version=${dep.version})`;
+		});
+		header += `${compatibilityScoreBadges.join(" ")}\n\n`;
+	}
+	const maxDescriptionLengthAfterHeaderAndFooter = 4e3 - header.length - 0;
+	return `${header}${description.substring(0, maxDescriptionLengthAfterHeaderAndFooter)}${footer}`;
+}
+
+//#endregion
+//#region src/azure/client.ts
+/** Azure DevOps REST API client. */
+var AzureDevOpsWebApiClient = class AzureDevOpsWebApiClient {
+	organisationApiUrl;
+	identityApiUrl;
+	accessToken;
+	debug;
+	authenticatedUserId;
+	resolvedUserIds;
+	static API_VERSION = "5.0";
+	static API_VERSION_PREVIEW = "5.0-preview";
+	constructor(url, accessToken, debug = false) {
+		const organisationApiUrl = url.url.toString();
+		this.organisationApiUrl = organisationApiUrl.replace(/\/$/, "");
+		this.identityApiUrl = getIdentityApiUrl(organisationApiUrl).replace(/\/$/, "");
+		this.accessToken = accessToken;
+		this.debug = debug;
+		this.resolvedUserIds = {};
+	}
+	/**
+	* Get the identity of the authenticated user.
+	* @returns
+	*/
+	async getUserId() {
+		if (!this.authenticatedUserId) {
+			this.authenticatedUserId = (await this.restApiGet(`${this.organisationApiUrl}/_apis/connectiondata`, void 0, AzureDevOpsWebApiClient.API_VERSION_PREVIEW))?.authenticatedUser?.id;
+			if (!this.authenticatedUserId) throw new Error("Failed to get authenticated user ID");
+		}
+		return this.authenticatedUserId;
+	}
+	/**
+	* Get the identity id from a user name, email, or group name.
+	* Requires scope "Identity (Read)" (vso.identity).
+	* @param userNameEmailOrGroupName
+	* @returns
+	*/
+	async resolveIdentityId(userNameEmailOrGroupName) {
+		if (this.resolvedUserIds[userNameEmailOrGroupName]) return this.resolvedUserIds[userNameEmailOrGroupName];
+		try {
+			const identities = await this.restApiGet(`${this.identityApiUrl}/_apis/identities`, {
+				searchFilter: "General",
+				filterValue: userNameEmailOrGroupName,
+				queryMembership: "None"
+			});
+			if (!identities?.value || identities.value.length === 0) return;
+			this.resolvedUserIds[userNameEmailOrGroupName] = identities.value[0]?.id;
+			return this.resolvedUserIds[userNameEmailOrGroupName];
+		} catch (e) {
+			logger.error(`Failed to resolve user id: ${e}`);
+			logger.debug(e);
+			return;
+		}
+	}
+	/**
+	* Get the default branch for a repository.
+	* Requires scope "Code (Read)" (vso.code).
+	* @param project
+	* @param repository
+	* @returns
+	*/
+	async getDefaultBranch(project, repository) {
+		try {
+			const repo = await this.restApiGet(`${this.organisationApiUrl}/${project}/_apis/git/repositories/${repository}`);
+			if (!repo) throw new Error(`Repository '${project}/${repository}' not found`);
+			return normalizeBranchName(repo.defaultBranch);
+		} catch (e) {
+			logger.error(`Failed to get default branch for '${project}/${repository}': ${e}`);
+			logger.debug(e);
+			return;
+		}
+	}
+	/**
+	* Get the list of branch names for a repository.
+	* Requires scope "Code (Read)" (vso.code).
+	* @param project
+	* @param repository
+	* @returns
+	*/
+	async getBranchNames(project, repository) {
+		try {
+			const refs = await this.restApiGet(`${this.organisationApiUrl}/${project}/_apis/git/repositories/${repository}/refs`);
+			if (!refs) throw new Error(`Repository '${project}/${repository}' not found`);
+			return refs.value?.map((r) => normalizeBranchName(r.name)) || [];
+		} catch (e) {
+			logger.error(`Failed to list branch names for '${project}/${repository}': ${e}`);
+			logger.debug(e);
+			return;
+		}
+	}
+	/**
+	* Get the properties for all active pull request created by the supplied user.
+	* Requires scope "Code (Read)" (vso.code).
+	* @param project
+	* @param repository
+	* @param creator
+	* @returns
+	*/
+	async getActivePullRequestProperties(project, repository, creator) {
+		try {
+			const pullRequests = await this.restApiGet(`${this.organisationApiUrl}/${project}/_apis/git/repositories/${repository}/pullrequests`, {
+				"searchCriteria.creatorId": isGuid(creator) ? creator : await this.getUserId(),
+				"searchCriteria.status": "Active"
+			});
+			if (!pullRequests?.value || pullRequests.value.length === 0) return [];
+			return await Promise.all(pullRequests.value.map(async (pr) => {
+				const properties = await this.restApiGet(`${this.organisationApiUrl}/${project}/_apis/git/repositories/${repository}/pullrequests/${pr.pullRequestId}/properties`);
+				return {
+					id: pr.pullRequestId,
+					properties: Object.keys(properties?.value || {}).map((key) => {
+						return {
+							name: key,
+							value: properties.value[key]?.$value
+						};
+					}) || []
+				};
+			}));
+		} catch (e) {
+			logger.error(`Failed to list active pull request properties: ${e}`);
+			logger.debug(e);
+			return [];
+		}
+	}
+	/**
+	* Create a new pull request.
+	* Requires scope "Code (Write)" (vso.code_write).
+	* Requires scope "Identity (Read)" (vso.identity), if assignees are specified.
+	* @param pr
+	* @returns
+	*/
+	async createPullRequest(pr) {
+		logger.info(`Creating pull request '${pr.title}'...`);
+		try {
+			const userId = await this.getUserId();
+			const reviewers = [];
+			if (pr.assignees && pr.assignees.length > 0) for (const assignee of pr.assignees) {
+				const identityId = isGuid(assignee) ? assignee : await this.resolveIdentityId(assignee);
+				if (identityId && !reviewers.some((r) => r.id === identityId)) reviewers.push({ id: identityId });
+				else logger.warn(`Unable to resolve assignee identity '${assignee}'`);
+			}
+			logger.info(` - Pushing ${pr.changes.length} file change(s) to branch '${pr.source.branch}'...`);
+			const push = await this.restApiPost(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pushes`, {
+				refUpdates: [{
+					name: `refs/heads/${pr.source.branch}`,
+					oldObjectId: pr.source.commit
+				}],
+				commits: [{
+					comment: pr.commitMessage,
+					author: pr.author,
+					changes: pr.changes.map((change) => {
+						return {
+							changeType: change.changeType,
+							item: { path: normalizeFilePath(change.path) },
+							newContent: {
+								content: Buffer.from(change.content, change.encoding).toString("base64"),
+								contentType: ItemContentType.Base64Encoded
+							}
+						};
+					})
+				}]
+			});
+			if (!push?.commits?.length) throw new Error("Failed to push changes to source branch, no commits were created");
+			logger.info(` - Pushed commit: ${push.commits.map((c) => c.commitId).join(", ")}.`);
+			logger.info(` - Creating pull request to merge '${pr.source.branch}' into '${pr.target.branch}'...`);
+			const pullRequest = await this.restApiPost(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pullrequests`, {
+				sourceRefName: `refs/heads/${pr.source.branch}`,
+				targetRefName: `refs/heads/${pr.target.branch}`,
+				title: pr.title,
+				description: pr.description,
+				reviewers,
+				workItemRefs: pr.workItems?.map((id) => ({ id })),
+				labels: pr.labels?.map((label) => ({ name: label }))
+			});
+			if (!pullRequest?.pullRequestId) throw new Error("Failed to create pull request, no pull request id was returned");
+			logger.info(` - Created pull request: #${pullRequest.pullRequestId}.`);
+			if (pr.properties && pr.properties.length > 0) {
+				logger.info(` - Adding dependency metadata to pull request properties...`);
+				if (!(await this.restApiPatch(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pullrequests/${pullRequest.pullRequestId}/properties`, pr.properties.map((property) => {
+					return {
+						op: "add",
+						path: `/${property.name}`,
+						value: property.value
+					};
+				}), "application/json-patch+json"))?.count) throw new Error("Failed to add dependency metadata properties to pull request");
+			}
+			if (pr.autoComplete) {
+				logger.info(` - Updating auto-complete options...`);
+				const updatedPullRequest = await this.restApiPatch(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pullrequests/${pullRequest.pullRequestId}`, {
+					autoCompleteSetBy: { id: userId },
+					completionOptions: {
+						autoCompleteIgnoreConfigIds: pr.autoComplete.ignorePolicyConfigIds,
+						deleteSourceBranch: true,
+						mergeCommitMessage: mergeCommitMessage(pullRequest.pullRequestId, pr.title, pr.description),
+						mergeStrategy: pr.autoComplete.mergeStrategy,
+						transitionWorkItems: false
+					}
+				});
+				if (!updatedPullRequest || updatedPullRequest.autoCompleteSetBy?.id !== userId) throw new Error("Failed to set auto-complete on pull request");
+			}
+			logger.info(` - Pull request was created successfully.`);
+			return pullRequest.pullRequestId;
+		} catch (e) {
+			logger.error(`Failed to create pull request: ${e}`);
+			logger.debug(e);
+			return null;
+		}
+	}
+	/**
+	* Update a pull request.
+	* Requires scope "Code (Read & Write)" (vso.code, vso.code_write).
+	* @param pr
+	* @returns
+	*/
+	async updatePullRequest(pr) {
+		logger.info(`Updating pull request #${pr.pullRequestId}...`);
+		try {
+			const pullRequest = await this.restApiGet(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pullrequests/${pr.pullRequestId}`);
+			if (!pullRequest) throw new Error(`Pull request #${pr.pullRequestId} not found`);
+			if (pr.skipIfDraft && pullRequest.isDraft) {
+				logger.info(` - Skipping update as pull request is currently marked as a draft.`);
+				return true;
+			}
+			if (pr.skipIfCommitsFromAuthorsOtherThan) {
+				if ((await this.restApiGet(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pullrequests/${pr.pullRequestId}/commits`))?.value?.some((c) => c.author?.email !== pr.skipIfCommitsFromAuthorsOtherThan)) {
+					logger.info(` - Skipping update as pull request has been modified by another user.`);
+					return true;
+				}
+			}
+			const stats = await this.restApiGet(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/stats/branches`, { name: normalizeBranchName(pullRequest.sourceRefName) });
+			if (stats?.behindCount === void 0) throw new Error(`Failed to get branch stats for '${pullRequest.sourceRefName}'`);
+			if (pr.skipIfNotBehindTargetBranch && stats.behindCount === 0) {
+				logger.info(` - Skipping update as source branch is not behind target branch.`);
+				return true;
+			}
+			const sourceBranchName = normalizeBranchName(pullRequest.sourceRefName);
+			const targetBranchName = normalizeBranchName(pullRequest.targetRefName);
+			if (stats.behindCount > 0) {
+				logger.info(` - Rebasing '${targetBranchName}' into '${sourceBranchName}' (${stats.behindCount} commit(s) behind)...`);
+				if ((await this.restApiPost(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/refs`, [{
+					name: pullRequest.sourceRefName,
+					oldObjectId: pullRequest.lastMergeSourceCommit.commitId,
+					newObjectId: pr.commit
+				}]))?.value?.[0]?.success !== true) throw new Error("Failed to rebase the target branch into the source branch");
+			}
+			logger.info(` - Pushing ${pr.changes.length} file change(s) to branch '${pullRequest.sourceRefName}'...`);
+			const push = await this.restApiPost(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pushes`, {
+				refUpdates: [{
+					name: pullRequest.sourceRefName,
+					oldObjectId: pr.commit
+				}],
+				commits: [{
+					comment: pullRequest.mergeStatus === PullRequestAsyncStatus.Conflicts ? "Resolve merge conflicts" : `Rebase '${sourceBranchName}' onto '${targetBranchName}'`,
+					author: pr.author,
+					changes: pr.changes.map((change) => {
+						return {
+							changeType: change.changeType,
+							item: { path: normalizeFilePath(change.path) },
+							newContent: {
+								content: Buffer.from(change.content, change.encoding).toString("base64"),
+								contentType: ItemContentType.Base64Encoded
+							}
+						};
+					})
+				}]
+			});
+			if (!push?.commits?.length) throw new Error("Failed to push changes to source branch, no commits were created");
+			logger.info(` - Pushed commit: ${push.commits.map((c) => c.commitId).join(", ")}.`);
+			logger.info(` - Pull request was updated successfully.`);
+			return true;
+		} catch (e) {
+			logger.error(`Failed to update pull request: ${e}`);
+			logger.debug(e);
+			return false;
+		}
+	}
+	/**
+	* Approve a pull request.
+	* Requires scope "Code (Write)" (vso.code_write).
+	* @param pr
+	* @returns
+	*/
+	async approvePullRequest(pr) {
+		logger.info(`Approving pull request #${pr.pullRequestId}...`);
+		try {
+			logger.info(` - Updating reviewer vote on pull request...`);
+			const userId = await this.getUserId();
+			if ((await this.restApiPut(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pullrequests/${pr.pullRequestId}/reviewers/${userId}`, {
+				vote: 10,
+				isReapprove: true
+			}, "7.1"))?.vote !== 10) throw new Error("Failed to approve pull request, vote was not recorded");
+			logger.info(` - Pull request was approved successfully.`);
+			return true;
+		} catch (e) {
+			logger.error(`Failed to approve pull request: ${e}`);
+			logger.debug(e);
+			return false;
+		}
+	}
+	/**
+	* Abandon a pull request.
+	* Requires scope "Code (Write)" (vso.code_write).
+	* @param pr
+	* @returns
+	*/
+	async abandonPullRequest(pr) {
+		logger.info(`Abandoning pull request #${pr.pullRequestId}...`);
+		try {
+			const userId = await this.getUserId();
+			if (pr.comment) {
+				logger.info(` - Adding abandonment reason comment to pull request...`);
+				if (!(await this.restApiPost(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pullrequests/${pr.pullRequestId}/threads`, {
+					status: CommentThreadStatus.Closed,
+					comments: [{
+						author: { id: userId },
+						content: pr.comment,
+						commentType: CommentType.System
+					}]
+				}))?.id) throw new Error("Failed to add comment to pull request, thread was not created");
+			}
+			logger.info(` - Abandoning pull request...`);
+			const abandonedPullRequest = await this.restApiPatch(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/pullrequests/${pr.pullRequestId}`, {
+				status: PullRequestStatus.Abandoned,
+				closedBy: { id: userId }
+			});
+			if (abandonedPullRequest?.status?.toLowerCase() !== "abandoned") throw new Error("Failed to abandon pull request, status was not updated");
+			if (pr.deleteSourceBranch) {
+				logger.info(` - Deleting source branch...`);
+				if ((await this.restApiPost(`${this.organisationApiUrl}/${pr.project}/_apis/git/repositories/${pr.repository}/refs`, [{
+					name: abandonedPullRequest.sourceRefName,
+					oldObjectId: abandonedPullRequest.lastMergeSourceCommit.commitId,
+					newObjectId: "0000000000000000000000000000000000000000",
+					isLocked: false
+				}]))?.value?.[0]?.success !== true) throw new Error("Failed to delete the source branch");
+			}
+			logger.info(` - Pull request was abandoned successfully.`);
+			return true;
+		} catch (e) {
+			logger.error(`Failed to abandon pull request: ${e}`);
+			logger.debug(e);
+			return false;
+		}
+	}
+	async restApiGet(url, params, apiVersion = AzureDevOpsWebApiClient.API_VERSION) {
+		params ??= {};
+		const queryString = Object.keys(params).map((key) => `${key}=${params[key]}`).join("&");
+		const fullUrl = `${url}?api-version=${apiVersion}${queryString ? `&${queryString}` : ""}`;
+		return await sendRestApiRequestWithRetry("GET", fullUrl, void 0, async () => {
+			return await fetch(fullUrl, {
+				method: "GET",
+				headers: {
+					Accept: "application/json",
+					Authorization: `Basic ${Buffer.from(`:${this.accessToken}`).toString("base64")}`
+				}
+			});
+		}, this.debug);
+	}
+	async restApiPost(url, data, apiVersion = AzureDevOpsWebApiClient.API_VERSION) {
+		const fullUrl = `${url}?api-version=${apiVersion}`;
+		return await sendRestApiRequestWithRetry("POST", fullUrl, data, async () => {
+			return await fetch(fullUrl, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Basic ${Buffer.from(`:${this.accessToken}`).toString("base64")}`
+				},
+				body: JSON.stringify(data)
+			});
+		}, this.debug);
+	}
+	async restApiPut(url, data, apiVersion = AzureDevOpsWebApiClient.API_VERSION) {
+		const fullUrl = `${url}?api-version=${apiVersion}`;
+		return await sendRestApiRequestWithRetry("PUT", fullUrl, data, async () => {
+			return await fetch(fullUrl, {
+				method: "PUT",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Basic ${Buffer.from(`:${this.accessToken}`).toString("base64")}`
+				},
+				body: JSON.stringify(data)
+			});
+		}, this.debug);
+	}
+	async restApiPatch(url, data, contentType, apiVersion = AzureDevOpsWebApiClient.API_VERSION) {
+		const fullUrl = `${url}?api-version=${apiVersion}`;
+		return await sendRestApiRequestWithRetry("PATCH", fullUrl, data, async () => {
+			return await fetch(fullUrl, {
+				method: "PATCH",
+				headers: {
+					"Content-Type": contentType || "application/json",
+					Authorization: `Basic ${Buffer.from(`:${this.accessToken}`).toString("base64")}`
+				},
+				body: JSON.stringify(data)
+			});
+		}, this.debug);
+	}
+};
+function mergeCommitMessage(id, title, description) {
+	return `Merged PR ${id}: ${title}\n\n${description}`.slice(0, 3500);
+}
+function isGuid(guid) {
+	return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(guid);
+}
+function getIdentityApiUrl(organisationApiUrl) {
+	const uri = new URL(organisationApiUrl);
+	const hostname = uri.hostname.toLowerCase();
+	if (hostname === "dev.azure.com" || hostname.endsWith(".visualstudio.com")) uri.host = "vssps.dev.azure.com";
+	return uri.toString();
+}
+async function sendRestApiRequestWithRetry(method, url, payload, requestAsync, isDebug = false, retryCount = 3, retryDelay = 3e3) {
+	let body;
+	try {
+		if (isDebug) logger.debug(`🌎 🠊 [${method}] ${url}`);
+		const response = await requestAsync();
+		body = await response.text();
+		const { status: statusCode, statusText: statusMessage } = response;
+		if (isDebug) logger.debug(`🌎 🠈 [${statusCode}] ${statusMessage}`);
+		if (statusCode < 200 || statusCode > 299) throw new HttpRequestError(`HTTP ${method} '${url}' failed: ${statusCode} ${statusMessage}`, statusCode);
+		return JSON.parse(body);
+	} catch (e) {
+		const err = e;
+		if (retryCount > 1 && isErrorTemporaryFailure(err)) {
+			logger.warn(err.message);
+			if (isDebug) logger.debug(`⏳ Retrying request in ${retryDelay}ms...`);
+			await new Promise((resolve) => setTimeout(resolve, retryDelay));
+			return sendRestApiRequestWithRetry(method, url, payload, requestAsync, isDebug, retryCount - 1, retryDelay);
+		}
+		if (isDebug) {
+			if (payload) logger.debug(`REQUEST: ${JSON.stringify(payload)}`);
+			if (body) logger.debug(`RESPONSE: ${body}`);
+		}
+		logger.trace(`THROW${e}`);
+		throw e;
+	}
+}
+
+//#endregion
+//#region src/azure/config.ts
+/**
+* Parse the dependabot config YAML file to specify update configuration.
+* The file should be located at any of `POSSIBLE_CONFIG_FILE_PATHS`.
+*
+* To view YAML file format, visit
+* https://docs.github.com/en/github/administering-a-repository/configuration-options-for-dependency-updates#allow
+*
+* @returns {DependabotConfig} config - the dependabot configuration
+*/
+async function getDependabotConfig({ url, token, remote, rootDir = process.cwd(), variableFinder }) {
+	let configPath;
+	let configContents;
+	if (remote) {
+		logger.debug(`Attempting to fetch configuration file via REST API ...`);
+		for (const fp of POSSIBLE_CONFIG_FILE_PATHS) {
+			const requestUrl = `${url.url}${url.project}/_apis/git/repositories/${url.repository}/items?path=/${fp}`;
+			logger.debug(`GET ${requestUrl}`);
+			try {
+				const authHeader = `Basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}`;
+				const response = await fetch(requestUrl, { headers: {
+					Authorization: authHeader,
+					Accept: "*/*"
+				} });
+				if (response.ok) {
+					logger.debug(`Found configuration file at '${requestUrl}'`);
+					configContents = await response.text();
+					configPath = fp;
+					break;
+				} else if (response.status === 404) {
+					logger.trace(`No configuration file at '${requestUrl}'`);
+					continue;
+				} else if (response.status === 401) throw new Error(`No or invalid access token has been provided to access '${requestUrl}'`);
+				else if (response.status === 403) throw new Error(`The access token provided does not have permissions to access '${requestUrl}'`);
+			} catch (error) {
+				if (error instanceof Error && error.message.includes("access token")) throw error;
+				else throw error;
+			}
+		}
+	} else for (const fp of POSSIBLE_CONFIG_FILE_PATHS) {
+		const filePath = path.join(rootDir, fp);
+		if (existsSync(filePath)) {
+			logger.debug(`Found configuration file cloned at ${filePath}`);
+			configContents = await readFile(filePath, "utf-8");
+			configPath = filePath;
+			break;
+		} else logger.trace(`No configuration file cloned at ${filePath}`);
+	}
+	if (!configContents || !configPath || typeof configContents !== "string") throw new Error(`Configuration file not found at possible locations: ${POSSIBLE_CONFIG_FILE_PATHS.join(", ")}`);
+	else logger.trace("Configuration file contents read.");
+	return await parseDependabotConfig({
+		configContents,
+		configPath,
+		variableFinder
+	});
+}
+
+//#endregion
+//#region src/azure/url-parts.ts
+function extractUrlParts({ organisationUrl, project, repository }) {
+	const url = new URL(organisationUrl);
+	const protocol = url.protocol.slice(0, -1);
+	let { hostname } = url;
+	if (/^(?<prefix>\S+)\.visualstudio\.com$/iu.test(hostname)) hostname = "dev.azure.com";
+	const organisation = extractOrganisation(organisationUrl);
+	const virtualDirectory = extractVirtualDirectory(url);
+	const apiEndpoint = `${protocol}://${hostname}${url.port ? `:${url.port}` : ""}/${virtualDirectory ? `${virtualDirectory}/` : ""}`;
+	const escapedProject = encodeURI(project);
+	const escapedRepository = encodeURI(repository);
+	const repoSlug = `${virtualDirectory ? `${virtualDirectory}/` : ""}${organisation}/${escapedProject}/_git/${escapedRepository}`;
+	return {
+		url,
+		hostname,
+		"api-endpoint": apiEndpoint,
+		project: escapedProject,
+		repository: escapedRepository,
+		"repository-slug": repoSlug
+	};
+}
+/**
+* Extract organisation name from organisation URL
+*
+* @param organisationUrl
+*
+* @returns organisation name
+*/
+function extractOrganisation(organisationUrl) {
+	const parts = organisationUrl.split("/");
+	if (parts.length === 6) return parts[4];
+	if (parts.length === 5) return parts[3];
+	if (parts.length === 4) return parts[2].split(".")[0];
+	throw new Error(`Error parsing organisation from organisation url: '${organisationUrl}'.`);
+}
+/**
+* Extract virtual directory from organisation URL
+*
+* Virtual Directories are sometimes used in on-premises
+* @param organisationUrl
+*
+* @returns virtual directory
+*
+* @example URLs typically are like this:`https://server.domain.com/tfs/x/` and `tfs` is the virtual directory
+*/
+function extractVirtualDirectory(organisationUrl) {
+	const path$1 = organisationUrl.pathname.split("/");
+	return path$1.length === 4 ? path$1[1] : void 0;
+}
+
+//#endregion
+export { AzureDevOpsWebApiClient, CommentThreadStatus, CommentType, DEVOPS_PR_PROPERTY_DEPENDABOT_DEPENDENCIES, DEVOPS_PR_PROPERTY_DEPENDABOT_PACKAGE_MANAGER, DEVOPS_PR_PROPERTY_MICROSOFT_GIT_SOURCE_REF_NAME, DependenciesPrPropertySchema, GitPullRequestMergeStrategy, ItemContentType, PullRequestAsyncStatus, PullRequestStatus, VersionControlChangeType, buildPullRequestProperties, extractUrlParts, getDependabotConfig, getPullRequestChangedFilesForOutputData, getPullRequestCloseReasonForOutputData, getPullRequestDependenciesPropertyValueForOutputData, getPullRequestDescription, getPullRequestForDependencyNames, normalizeBranchName, normalizeFilePath, parsePullRequestProperties, sendRestApiRequestWithRetry };
+//# sourceMappingURL=azure.js.map