should-delete-fork.js

'use strict';

const getBranchPRStatus = async (github, repo, branch) => {
	try {
		const {data: prs} = await github.pulls.list({
			owner: repo.parent.owner.login,
			repo: repo.parent.name,
			state: 'all',
			head: `${repo.owner.login}:${branch.name}`,
			per_page: 1
		});

		if (prs.length === 0) {
			return null;
		}

		const pr = prs[0];
		if (pr.merged_at) {
			return 'merged';
		}

		if (pr.state === 'closed') {
			return 'closed';
		}

		return 'open';
	} catch {
		return null;
	}
};

const branchIsUseful = async (github, repo, branch, parentBranches) => {
	const someParentBranchAtThisSha =
		parentBranches.filter(candidate => {
			return branch.commit.sha === candidate.commit.sha;
		}).length === 1;

	if (someParentBranchAtThisSha) {
		return false;
	}

	const prStatus = await getBranchPRStatus(github, repo, branch);
	if (prStatus === 'merged') {
		return false;
	}

	if (prStatus === 'open' || prStatus === 'closed') {
		return true;
	}

	// Check if at least one parent branch contains this commit
	// Looping through all parent branches is immensely slow,
	// let's take a safe shortcut
	const sameName = parentBranches.find(b => b.name === branch.name);
	const defaultBranch = parentBranches.find(b => b.name === repo.default_branch);

	// If branch doesn't exist in parent and has no PR, it's likely a deleted
	// upstream branch that was synced - consider it useless
	if (!sameName) {
		return false;
	}

	// Build list of branches to check, avoiding duplicates
	const branchesToCheck = [sameName];
	if (defaultBranch && defaultBranch.name !== sameName.name) {
		branchesToCheck.push(defaultBranch);
	}

	for (const candidate of branchesToCheck) {
		try {
			const {data: diff} = await github.repos.compareCommits({
				owner: repo.parent.owner.login,
				repo: repo.parent.name,
				base: branch.commit.sha,
				head: candidate.name
			});
			// If parent is not behind us, this parent candidate
			// branch contains our branch
			if (diff.behind_by) {
				return true;
			}
		} catch (error) {
			// If diff can't be found, means our commit is not on this
			// parent branch candidate
			// Note: error.status can be a number or string depending on the error type
			if (Number(error.status) === 404) {
				continue;
			}

			throw error;
		}
	}

	return false;
};

module.exports = async (github, fork) => {
	// Grab the repository information
	const {data: repo} = await github.repos.get({
		owner: fork.owner.login,
		repo: fork.name
	});

	// Grab all branches
	const {data: branches} = await github.repos.listBranches({
		owner: repo.owner.login,
		repo: repo.name,
		per_page: 100
	});

	if (branches.length === 100) {
		// There are too many branches,
		// dealing with pagination is not supported
		return false;
	}

	// Grab all parent repository branches
	let parentbranches;
	try {
		({data: parentbranches} = await github.repos.listBranches({
			owner: repo.parent.owner.login,
			repo: repo.parent.name,
			per_page: 100
		}));
	} catch (error) {
		// If parent repository was deleted, need to preserve the fork
		// Note: error.status can be a number or string depending on the error type
		if (error && Number(error.status) === 404) {
			return false;
		}

		throw error;
	}

	// Compare if for each local branch is useless
	if (branches.length > parentbranches.length) {
		// Quick common case
		return false;
	}

	for (const branch of branches) {
		const useful = await branchIsUseful(github, repo, branch, parentbranches);
		if (useful) {
			return false;
		}
	}

	return true;
};