/*---------------------------------------------------------------------------------------------

* Copyright (c) Microsoft Corporation. All rights reserved.

* Licensed under the MIT License. See License.txt in the project root for license information.

*--------------------------------------------------------------------------------------------*/

import * as buffer from 'buffer';

import { ApolloQueryResult, DocumentNode, FetchResult, MutationOptions, NetworkStatus, OperationVariables, QueryOptions } from 'apollo-boost';

import LRUCache from 'lru-cache';

import * as vscode from 'vscode';

import { mergeQuerySchemaWithShared, OctokitCommon } from './common';

import { CredentialStore, GitHub } from './credentials';

import {

AssignableUsersResponse,

CreatePullRequestResponse,

FileContentResponse,

ForkDetailsResponse,

GetBranchResponse,

GetChecksResponse,

isCheckRun,

IssueResponse,

IssuesSearchResponse,

ListBranchesResponse,

MaxIssueResponse,

MentionableUsersResponse,

MergeQueueForBranchResponse,

MilestoneIssuesResponse,

OrganizationTeamsCountResponse,

OrganizationTeamsResponse,

OrgProjectsResponse,

PullRequestNumberData,

PullRequestNumbersResponse,

PullRequestParticipantsResponse,

PullRequestResponse,

PullRequestsResponse,

PullRequestTemplatesResponse,

RepoProjectsResponse,

RevertPullRequestResponse,

SuggestedActorsResponse,

UserResponse,

ViewerPermissionResponse,

} from './graphql';

import {

CheckState,

IAccount,

IMilestone,

IProject,

Issue,

ITeam,

MergeMethod,

PullRequest,

PullRequestChecks,

PullRequestCheckStatus,

PullRequestReviewRequirement,

RepoAccessAndMergeMethods,

User,

} from './interface';

import { IssueChangeEvent, IssueModel } from './issueModel';

import { getErrorCode, LoggingOctokit } from './loggingOctokit';

import { PullRequestModel } from './pullRequestModel';

import defaultSchema from './queries.gql';

import * as extraSchema from './queriesExtra.gql';

import * as limitedSchema from './queriesLimited.gql';

import * as sharedSchema from './queriesShared.gql';

import {

convertRESTPullRequestToRawPullRequest,

getAvatarWithEnterpriseFallback,

getOverrideBranch,

isInCodespaces,

parseAccount,

parseGraphQLIssue,

parseGraphQLPullRequest,

parseGraphQLUser,

parseGraphQLViewerPermission,

parseMergeMethod,

parseMilestone,

restPaginate,

} from './utils';

import { AuthenticationError, AuthProvider, GitHubServerType, isSamlError } from '../common/authentication';

import { Disposable, disposeAll } from '../common/lifecycle';

import Logger from '../common/logger';

import { GitHubRemote, parseRemote } from '../common/remote';

import { BRANCH_LIST_TIMEOUT, PR_SETTINGS_NAMESPACE } from '../common/settingKeys';

import { ITelemetry } from '../common/telemetry';

import { PullRequestCommentController } from '../view/pullRequestCommentController';

import { PRCommentControllerRegistry } from '../view/pullRequestCommentControllerRegistry';

export const PULL_REQUEST_PAGE_SIZE = 20;

const GRAPHQL_COMPONENT_ID = 'GraphQL';

export interface ItemsData<T> {

items: T[];

hasMorePages: boolean;

totalCount?: number;

}

export interface IssueData extends ItemsData<Issue> {

items: Issue[];

hasMorePages: boolean;

}

export interface PullRequestData extends ItemsData<PullRequestModel> {

items: PullRequestModel[];

}

export interface MilestoneData extends ItemsData<{ milestone: IMilestone; issues: IssueModel[] }> {

items: { milestone: IMilestone; issues: IssueModel[] }[];

hasMorePages: boolean;

}

export enum ViewerPermission {

Unknown = 'unknown',

Admin = 'ADMIN',

Maintain = 'MAINTAIN',

Read = 'READ',

Triage = 'TRIAGE',

Write = 'WRITE',

}

export class RateLimitError extends Error {

constructor(message?: string) {

super(message ?? 'GitHub API rate limit exceeded');

this.name = 'RateLimitError';

}

}

export function isRateLimitError(e: unknown): boolean {

if (e instanceof RateLimitError) {

return true;

}

if (e instanceof Error) {

const msg = e.message.toLowerCase();

if (msg.includes('rate limit') || msg.includes('secondary rate') || msg.includes('abuse detection')) {

return true;

}

}

return false;

}

export enum TeamReviewerRefreshKind {

None,

Try,

Force

}

export interface ForkDetails {

isFork: boolean;

parent: {

owner: {

login: string;

};

name: string;

};

}

export type IMetadata = OctokitCommon.ReposGetResponseData;

export enum GraphQLErrorType {

Unprocessable = 'UNPROCESSABLE',

}

export interface GraphQLError {

extensions?: {

code: string;

};

type?: GraphQLErrorType;

message?: string;

}

export enum CopilotWorkingStatus {

NotCopilotIssue = 'NotCopilotIssue',

InProgress = 'InProgress',

Error = 'Error',

Done = 'Done',

}

export interface PullRequestChangeEvent {

model: IssueModel;

event: IssueChangeEvent;

}

export class GitHubRepository extends Disposable {

static ID = 'GitHubRepository';

private static _allRepoIds: Set<number> = new Set();

private static _succeededPullRequests: Map<number, Set<number>> = new Map();

protected _initialized: boolean = false;

protected _hub: GitHub | undefined;

protected _metadata: Promise<IMetadata> | undefined;

public commentsController?: vscode.CommentController;

public commentsHandler?: PRCommentControllerRegistry;

private _pullRequestModelsByNumber: LRUCache<number, { model: PullRequestModel, disposables: vscode.Disposable[] }> = new LRUCache({

maxAge: 1000 * 60 * 60 * 4 /* 4 hours */, stale: true, updateAgeOnGet: true,

dispose: (_key, value) => {

disposeAll(value.disposables);

value.model.dispose();

}

});

private _issueModelsByNumber: LRUCache<number, { model: IssueModel, disposables: vscode.Disposable[] }> = new LRUCache({

maxAge: 1000 * 60 * 60 * 4 /* 4 hours */, stale: true, updateAgeOnGet: true,

dispose: (_key, value) => {

disposeAll(value.disposables);

value.model.dispose();

}

});

// eslint-disable-next-line rulesdir/no-any-except-union-method-signature

private _queriesSchema: any;

private _areQueriesLimited: boolean = false;

private static readonly MAX_ITEM_NUMBER_TTL_MS = 60 * 60 * 1000; /* 1 hour */

private static readonly MAX_ITEM_NUMBER_BUFFER = 50;

private _maxItemNumberCache: { value: number; fetchedAt: number } | undefined;

private _maxItemNumberPromise: Promise<number | undefined> | undefined;

get areQueriesLimited(): boolean { return this._areQueriesLimited; }

private _branchesCache: Map<string, string[]> = new Map();

private _onDidAddPullRequest: vscode.EventEmitter<PullRequestModel> = this._register(new vscode.EventEmitter());

public readonly onDidAddPullRequest: vscode.Event<PullRequestModel> = this._onDidAddPullRequest.event;

private _onDidChangePullRequests: vscode.EventEmitter<PullRequestChangeEvent[]> = this._register(new vscode.EventEmitter());

public readonly onDidChangePullRequests: vscode.Event<PullRequestChangeEvent[]> = this._onDidChangePullRequests.event;

public get hub(): GitHub {

if (!this._hub) {

if (!this._initialized) {

throw new Error('Call ensure() before accessing this property.');

} else {

throw new AuthenticationError();

}

}

return this._hub;

}

public equals(repo: GitHubRepository): boolean {

return this.remote.equals(repo.remote);

}

getExistingPullRequestModel(prNumber: number): PullRequestModel | undefined {

return this._pullRequestModelsByNumber.get(prNumber)?.model;

}

getExistingIssueModel(issueNumber: number): IssueModel | undefined {

return this._issueModelsByNumber.get(issueNumber)?.model;

}

get pullRequestModels(): PullRequestModel[] {

return Array.from(this._pullRequestModelsByNumber.values().map(value => value.model));

}

get issueModels(): IssueModel[] {

return Array.from(this._issueModelsByNumber.values().map(value => value.model));

}

public async ensureCommentsController(): Promise<void> {

try {

await this.ensure();

if (this.commentsController) {

return;

}

this.commentsController = vscode.comments.createCommentController(

`${PullRequestCommentController.PREFIX}-${this.remote.gitProtocol.normalizeUri()?.authority}-${this.remote.remoteName}-${this.remote.owner}-${this.remote.repositoryName}`,

`Pull Request (${this.remote.owner}/${this.remote.repositoryName})`,

);

this.commentsHandler = new PRCommentControllerRegistry(this.commentsController, this.telemetry);

this._register(this.commentsHandler);

this._register(this.commentsController);

} catch (e) {

console.log(e);

}

}

override dispose() {

super.dispose();

GitHubRepository._allRepoIds.delete(this._id);

for (const repoIds of GitHubRepository._succeededPullRequests.values()) {

repoIds.delete(this._id);

}

this.commentsController = undefined;

this.commentsHandler = undefined;

}

public get octokit(): LoggingOctokit {

return this.hub && this.hub.octokit;

}

private get id(): string {

return `${GitHubRepository.ID}+${this._id}`;

}

constructor(

private readonly _id: number,

public remote: GitHubRemote,

public readonly rootUri: vscode.Uri,

private readonly _credentialStore: CredentialStore,

public readonly telemetry: ITelemetry,

silent: boolean = false

) {

super();

GitHubRepository._allRepoIds.add(this._id);

this._queriesSchema = mergeQuerySchemaWithShared(sharedSchema.default, defaultSchema);

// kick off the comments controller early so that the Comments view is visible and doesn't pop up later in an way that's jarring

if (!silent) {

this.ensureCommentsController();

}

}

get authMatchesServer(): boolean {

if ((this.remote.githubServerType === GitHubServerType.GitHubDotCom) && this._credentialStore.isAuthenticated(AuthProvider.github)) {

return true;

} else if ((this.remote.githubServerType === GitHubServerType.Enterprise) && this._credentialStore.isAuthenticated(AuthProvider.githubEnterprise)) {

return true;

} else {

// Not good. We have a mismatch between auth type and server type.

return false;

}

}

private async codespacesTokenError<T>(action: QueryOptions | MutationOptions<T>) {

if (isInCodespaces() && (await this._metadata)?.fork) {

// :( https://github.com/microsoft/vscode-pull-request-github/issues/5325#issuecomment-1798243852

/* __GDPR__

"pr.codespacesTokenError" : {

"action": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }

}

*/

this.telemetry.sendTelemetryErrorEvent('pr.codespacesTokenError', {

action: action.context

});

throw new Error(vscode.l10n.t('This action cannot be completed in a GitHub Codespace on a fork.'));

}

}

query = async <T>(query: QueryOptions, ignoreSamlErrors: boolean = false, legacyFallback?: { query: DocumentNode, variables?: OperationVariables }): Promise<ApolloQueryResult<T>> => {

const gql = this.authMatchesServer && this.hub && this.hub.graphql;

if (!gql) {

const logValue = (query.query.definitions[0] as { name: { value: string } | undefined }).name?.value;

Logger.debug(`Not available for query: ${logValue ?? 'unknown'}`, GRAPHQL_COMPONENT_ID);

const empty: ApolloQueryResult<T> = {

data: null as T,

loading: false,

networkStatus: NetworkStatus.error,

stale: false,

} satisfies ApolloQueryResult<T>;

return empty;

}

let rsp;

try {

rsp = await gql.query<T>(query);

} catch (e) {

const logInfo = (query.query.definitions[0] as { name: { value: string } | undefined }).name?.value;

const gqlErrors = e.graphQLErrors ? e.graphQLErrors as GraphQLError[] : undefined;

Logger.error(`Error querying GraphQL API (${logInfo}): ${e.message}${gqlErrors ? `. ${gqlErrors.map(error => error.extensions?.code).join(',')}` : ''}`, this.id);

if (legacyFallback) {

query.query = legacyFallback.query;

query.variables = legacyFallback.variables;

return this.query(query, ignoreSamlErrors);

}

if (gqlErrors && gqlErrors.length && (gqlErrors.some(error => error.extensions?.code === 'undefinedField')) && !this._areQueriesLimited) {

// We're running against a GitHub server that doesn't support the query we're trying to run.

// Switch to the limited schema and try again.

this._areQueriesLimited = true;

this._queriesSchema = mergeQuerySchemaWithShared(sharedSchema.default, limitedSchema.default);

query.query = this.schema[(query.query.definitions[0] as { name: { value: string } }).name.value];

rsp = await gql.query<T>(query);

} else if (ignoreSamlErrors && isSamlError(e)) {

// Some queries just result in SAML errors.

} else if ((e.message as string | undefined)?.includes('401 Unauthorized')) {

await this._credentialStore.recreate(vscode.l10n.t('Your authentication session has lost authorization. You need to sign in again to regain authorization.'));

rsp = await gql.query<T>(query);

} else {

if (e.graphQLErrors && e.graphQLErrors.length && e.graphQLErrors[0].message === 'Resource not accessible by integration') {

await this.codespacesTokenError(query);

}

throw e;

}

}

return rsp;

};

mutate = async <T>(mutation: MutationOptions<T>, legacyFallback?: { mutation: DocumentNode, deleteProps: string[] }): Promise<FetchResult<T>> => {

const gql = this.authMatchesServer && this.hub && this.hub.graphql;

if (!gql) {

Logger.debug(`Not available for query: ${mutation.context as string}`, GRAPHQL_COMPONENT_ID);

const empty: FetchResult<T> = {

data: null

};

return empty;

}

let rsp: FetchResult<T>;

try {

rsp = await gql.mutate<T>(mutation);

} catch (e) {

if (legacyFallback) {

mutation.mutation = legacyFallback.mutation;

if (mutation.variables?.input) {

for (const prop of legacyFallback.deleteProps) {

delete mutation.variables.input[prop];

}

}

return this.mutate(mutation);

} else if (e.graphQLErrors && e.graphQLErrors.length && e.graphQLErrors[0].message === 'Resource not accessible by integration') {

await this.codespacesTokenError(mutation);

}

throw e;

}

return rsp;

};

get schema() {

return this._queriesSchema;

}

private async getMetadataForRepo(owner: string, repo: string): Promise<IMetadata> {

if (this._metadata && this.remote.owner === owner && this.remote.repositoryName === repo) {

Logger.debug(`Using cached metadata for repo ${owner}/${repo}`, this.id);

return this._metadata;

}

Logger.debug(`Fetch metadata for repo - enter`, this.id);

const { octokit } = await this.ensure();

const result = await octokit.call(octokit.api.repos.get, {

owner,

repo

});

Logger.debug(`Fetch metadata for repo ${owner}/${repo} - done`, this.id);

const metadata = { ...result.data, currentUser: await this._hub?.currentUser };

return metadata;

}

async getMetadata(): Promise<IMetadata> {

if (this._metadata) {

const metadata = await this._metadata;

Logger.debug(`Using cached metadata ${metadata.owner?.login}/${metadata.name}`, this.id);

return metadata;

}

Logger.debug(`Fetch metadata - enter`, this.id);

const { remote } = await this.ensure();

this._metadata = this.getMetadataForRepo(remote.owner, remote.repositoryName);

Logger.debug(`Fetch metadata ${remote.owner}/${remote.repositoryName} - done`, this.id);

return this._metadata;

}

/**

* Resolves remotes with redirects.

* @returns

*/

async resolveRemote(): Promise<boolean> {

try {

const { clone_url } = await this.getMetadata();

this.remote = GitHubRemote.remoteAsGitHub(parseRemote(this.remote.remoteName, clone_url, this.remote.gitProtocol)!, this.remote.githubServerType);

} catch (e) {

Logger.warn(`Unable to resolve remote: ${e}`);

if (isSamlError(e)) {

return false;

}

}

return true;

}

async ensure(additionalScopes: boolean = false): Promise<GitHubRepository> {

this._initialized = true;

const oldHub = this._hub;

if (!this._credentialStore.isAuthenticated(this.remote.authProviderId)) {

// We need auth now. (ex., a PR is already checked out)

// We can no longer wait until later for login to be done

await this._credentialStore.create(undefined, additionalScopes);

if (!this._credentialStore.isAuthenticated(this.remote.authProviderId)) {

this._hub = await this._credentialStore.showSignInNotification(this.remote.authProviderId);

}

} else {

if (additionalScopes) {

this._hub = await this._credentialStore.getHubEnsureAdditionalScopes(this.remote.authProviderId);

} else {

this._hub = this._credentialStore.getHub(this.remote.authProviderId);

}

}

if (oldHub !== this._hub) {

if (this._areQueriesLimited || this._credentialStore.areScopesOld(this.remote.authProviderId) || (this.remote.authProviderId === AuthProvider.githubEnterprise)) {

this._areQueriesLimited = true;

this._queriesSchema = mergeQuerySchemaWithShared(sharedSchema.default, limitedSchema.default);

} else {

if (this._credentialStore.areScopesExtra(this.remote.authProviderId)) {

this._queriesSchema = mergeQuerySchemaWithShared(sharedSchema.default, extraSchema.default);

} else {

this._queriesSchema = mergeQuerySchemaWithShared(sharedSchema.default, defaultSchema);

}

}

}

return this;

}

async ensureAdditionalScopes(): Promise<GitHubRepository> {

return this.ensure(true);

}

async getDefaultBranch(): Promise<string> {

const overrideSetting = getOverrideBranch();

if (overrideSetting) {

return overrideSetting;

}

try {

const data = await this.getMetadata();

return data.default_branch;

} catch (e) {

Logger.warn(`Fetching default branch failed: ${e}`, this.id);

}

return 'master';

}

async getPullRequestTemplates(): Promise<string[] | undefined> {

try {

Logger.debug('Fetch pull request templates - enter', this.id);

const { query, remote, schema } = await this.ensure();

const result = await query<PullRequestTemplatesResponse>({

query: schema.PullRequestTemplates,

variables: {

owner: remote.owner,

name: remote.repositoryName,

}

});

Logger.debug('Fetch pull request templates - done', this.id);

return result.data.repository.pullRequestTemplates.map(template => template.body);

} catch (e) {

Logger.error(`Fetching pull request templates failed: ${e}`, this.id);

const properties: { errorCode?: string } = {};

const errorCode = getErrorCode(e);

if (errorCode) {

properties.errorCode = errorCode;

}

/* __GDPR__

"pr.getPullRequestTemplatesFailed" : {

"errorCode": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }

}

*/

this.telemetry.sendTelemetryErrorEvent('pr.getPullRequestTemplatesFailed', properties);

}

}

private _repoAccessAndMergeMethods: RepoAccessAndMergeMethods | undefined;

async getRepoAccessAndMergeMethods(refetch: boolean = false): Promise<RepoAccessAndMergeMethods> {

try {

if (!this._repoAccessAndMergeMethods || refetch) {

Logger.debug(`Fetch repo permissions and available merge methods - enter`, this.id);

const data = await this.getMetadata();

Logger.debug(`Fetch repo permissions and available merge methods - done`, this.id);

const hasWritePermission = data.permissions?.push ?? false;

this._repoAccessAndMergeMethods = {

// Users with push access to repo have rights to merge/close PRs,

// edit title/description, assign reviewers/labels etc.

hasWritePermission,

mergeMethodsAvailability: {

merge: data.allow_merge_commit ?? false,

squash: data.allow_squash_merge ?? false,

rebase: data.allow_rebase_merge ?? false,

},

viewerCanAutoMerge: (data.allow_auto_merge && hasWritePermission) ?? false

};

}

return this._repoAccessAndMergeMethods;

} catch (e) {

Logger.warn(`GitHubRepository> Fetching repo permissions and available merge methods failed: ${e}`);

}

return {

hasWritePermission: true,

mergeMethodsAvailability: {

merge: true,

squash: true,

rebase: true,

},

viewerCanAutoMerge: false

};

}

private _branchHasMergeQueue: Map<string, MergeMethod> = new Map();

async mergeQueueMethodForBranch(branch: string): Promise<MergeMethod | undefined> {

if (this._branchHasMergeQueue.has(branch)) {

return this._branchHasMergeQueue.get(branch)!;

}

try {

Logger.debug('Fetch branch has merge queue - enter', this.id);

const { query, remote, schema } = await this.ensure();

if (!schema.MergeQueueForBranch) {

return undefined;

}

const result = await query<MergeQueueForBranchResponse>({

query: schema.MergeQueueForBranch,

variables: {

owner: remote.owner,

name: remote.repositoryName,

branch

}

});

Logger.debug('Fetch branch has merge queue - done', this.id);

const mergeMethod = parseMergeMethod(result.data.repository.mergeQueue?.configuration?.mergeMethod);

if (mergeMethod) {

this._branchHasMergeQueue.set(branch, mergeMethod);

}

return mergeMethod;

} catch (e) {

Logger.error(`Fetching branch has merge queue failed: ${e}`, this.id);

}

}

async commit(branch: string, message: string, files: Map<string, Uint8Array>): Promise<boolean> {

Logger.debug(`Committing files to branch ${branch} - enter`, this.id);

let success = false;

try {

const { octokit, remote } = await this.ensure();

const lastCommitSha = (await octokit.call(octokit.api.repos.getBranch, { owner: remote.owner, repo: remote.repositoryName, branch })).data.commit.sha;

const lastTreeSha = (await octokit.call(octokit.api.repos.getCommit, { owner: remote.owner, repo: remote.repositoryName, ref: lastCommitSha })).data.commit.tree.sha;

const treeItems: { path: string, mode: '100644', content: string }[] = [];

for (const [path, content] of files) {

treeItems.push({ path: path.substring(1), mode: '100644', content: content.toString() });

}

const newTreeSha = (await octokit.call(octokit.api.git.createTree, { owner: remote.owner, repo: remote.repositoryName, base_tree: lastTreeSha, tree: treeItems })).data.sha;

const newCommitSha = (await octokit.call(octokit.api.git.createCommit, { owner: remote.owner, repo: remote.repositoryName, message, tree: newTreeSha, parents: [lastCommitSha] })).data.sha;

await octokit.call(octokit.api.git.updateRef, { owner: remote.owner, repo: remote.repositoryName, ref: `heads/${branch}`, sha: newCommitSha });

success = true;

} catch (e) {

// not sure what kinds of errors to expect here

Logger.error(`Committing files to branch ${branch} failed: ${e}`, this.id);

}

Logger.debug(`Committing files to branch ${branch} - done`, this.id);

return success;

}

async getCommitParent(ref: string): Promise<string | undefined> {

Logger.debug(`Fetch commit for ref ${ref} - enter`, this.id);

try {

const { octokit, remote } = await this.ensure();

const commit = (await octokit.call(octokit.api.repos.getCommit, { owner: remote.owner, repo: remote.repositoryName, ref })).data;

return commit.parents[0].sha;

} catch (e) {

Logger.error(`Fetching commit for ref ${ref} failed: ${e}`, this.id);

}

Logger.debug(`Fetch commit for ref ${ref} - done`, this.id);

}

async getAllPullRequests(page?: number): Promise<PullRequestData | undefined> {

let remote: GitHubRemote | undefined;

try {

Logger.debug(`Fetch all pull requests - enter`, this.id);

const ensured = await this.ensure();

remote = ensured.remote;

const octokit = ensured.octokit;

const result = await octokit.call(octokit.api.pulls.list, {

owner: remote.owner,

repo: remote.repositoryName,

per_page: PULL_REQUEST_PAGE_SIZE,

page: page || 1,

});

const hasMorePages = !!result.headers.link && result.headers.link.indexOf('rel="next"') > -1;

if (!result.data) {

// We really don't expect this to happen, but it seems to (see #574).

// Log a warning and return an empty set.

Logger.warn(

`No result data for ${remote.owner}/${remote.repositoryName} Status: ${result.status}`,

);

return {

items: [],

hasMorePages: false,

totalCount: 0

};

}

const pullRequests = result.data

.map(pullRequest => {

if (!pullRequest.head.repo) {

Logger.appendLine('The remote branch for this PR was already deleted.', this.id);

return null;

}

return this.createOrUpdatePullRequestModel(

convertRESTPullRequestToRawPullRequest(pullRequest, this),

);

})

.filter(item => item !== null) as PullRequestModel[];

Logger.debug(`Fetch all pull requests - done`, this.id);

return {

items: pullRequests,

hasMorePages

};

} catch (e) {

Logger.error(`Fetching all pull requests failed: ${e}`, this.id);

if (e.status === 404) {

// not found

vscode.window.showWarningMessage(

`Fetching all pull requests for remote '${remote?.remoteName}' failed, please check if the repository ${remote?.owner}/${remote?.repositoryName} is valid.`,

);

} else {

throw e;

}

}

return undefined;

}

async getPullRequestNumbers(): Promise<PullRequestNumberData[] | undefined> {

let remote: GitHubRemote | undefined;

try {

Logger.debug(`Fetch pull request numbers - enter`, this.id);

const ensured = await this.ensure();

remote = ensured.remote;

const { query, schema } = ensured;

const { data } = await query<PullRequestNumbersResponse>({

query: schema.PullRequestNumbers,

variables: {

owner: remote.owner,

name: remote.repositoryName,

first: 100,

},

});

Logger.debug(`Fetch pull request numbers - done`, this.id);

if (data?.repository?.pullRequests) {

return data.repository.pullRequests.nodes;

}

} catch (e) {

Logger.error(`Fetching pull request numbers failed: ${e}`, this.id);

if (e.status === 404) {

// not found

vscode.window.showWarningMessage(

`Fetching pull request numbers for remote '${remote?.remoteName}' failed, please check if the repository ${remote?.owner}/${remote?.repositoryName} is valid.`,

);

} else {

throw e;

}

}

return undefined;

}

async getPullRequestForBranch(branch: string, headOwner: string): Promise<PullRequestModel | undefined> {

let remote: GitHubRemote | undefined;

try {

Logger.debug(`Fetch pull requests for branch - enter`, this.id);

const ensured = await this.ensure();

remote = ensured.remote;

const { query, schema } = ensured;

const { data } = await query<PullRequestsResponse>({

query: schema.PullRequestForHead,

variables: {

owner: remote.owner,

name: remote.repositoryName,

headRefName: branch,

},

});

Logger.debug(`Fetch pull requests for branch - done`, this.id);

if (data?.repository && data.repository.pullRequests.nodes.length > 0) {

const prs = (await Promise.all(data.repository.pullRequests.nodes.map(node => parseGraphQLPullRequest(node, this)))).filter(pr => pr.head?.repo.owner === headOwner);

if (prs.length === 0) {

return undefined;

}

const mostRecentOrOpenPr = prs.find(pr => pr.state.toLowerCase() === 'open') ?? prs[0];

return this.createOrUpdatePullRequestModel(mostRecentOrOpenPr);

}

} catch (e) {

Logger.error(`Fetching pull request for branch failed: ${e}`, this.id);

if (e.status === 404) {

// not found

vscode.window.showWarningMessage(

`Fetching pull request for branch for remote '${remote?.remoteName}' failed, please check if the repository ${remote?.owner}/${remote?.repositoryName} is valid.`,

);

}

}

return undefined;

}

async canGetProjectsNow(): Promise<boolean> {

let { schema } = await this.ensure();

if (schema.GetRepoProjects && schema.GetOrgProjects) {

return true;

}

return false;

}

async getOrgProjects(): Promise<IProject[]> {

Logger.debug(`Fetch org projects - enter`, this.id);

let { query, remote, schema } = await this.ensure();

const projects: IProject[] = [];

try {

const { data } = await query<OrgProjectsResponse>({

query: schema.GetOrgProjects,

variables: {

owner: remote.owner,

after: null,

}

});

if (data && data.organization.projectsV2 && data.organization.projectsV2.nodes) {

data.organization.projectsV2.nodes.forEach(raw => {

projects.push(raw);

});

}

} catch (e) {

Logger.error(`Unable to fetch org projects: ${e}`, this.id);

return projects;

}

Logger.debug(`Fetch org projects - done`, this.id);

return projects;

}

async getProjects(): Promise<IProject[] | undefined> {

try {

Logger.debug(`Fetch projects - enter`, this.id);

let { query, remote, schema } = await this.ensure();

if (!schema.GetRepoProjects) {

const additional = await this.ensureAdditionalScopes();

query = additional.query;

remote = additional.remote;

schema = additional.schema;

}

const { data } = await query<RepoProjectsResponse>({

query: schema.GetRepoProjects,

variables: {

owner: remote.owner,

name: remote.repositoryName,

},

});

Logger.debug(`Fetch projects - done`, this.id);

const projects: IProject[] = [];

if (data && data.repository?.projectsV2 && data.repository.projectsV2.nodes) {

data.repository.projectsV2.nodes.forEach(raw => {

projects.push(raw);

});

}

return projects;

} catch (e) {

Logger.error(`Unable to fetch projects: ${e}`, this.id);

return;

}

}

async getMilestones(includeClosed: boolean = false): Promise<IMilestone[] | undefined> {

try {

Logger.debug(`Fetch milestones - enter`, this.id);

const { query, remote, schema } = await this.ensure();

const states = ['OPEN'];

if (includeClosed) {

states.push('CLOSED');

}

const { data } = await query<MilestoneIssuesResponse>({

query: schema.GetMilestones,

variables: {

owner: remote.owner,

name: remote.repositoryName,

states: states,

},

});

Logger.debug(`Fetch milestones - done`, this.id);

const milestones: IMilestone[] = [];

if (data && data.repository?.milestones && data.repository.milestones.nodes) {

data.repository.milestones.nodes.forEach(raw => {

const milestone = parseMilestone(raw);

if (milestone) {

milestones.push(milestone);

}

});

}

return milestones;

} catch (e) {

Logger.error(`Unable to fetch milestones: ${e}`, this.id);

return;

}

}

async getLines(sha: string, file: string, lineStart: number, lineEnd: number): Promise<string | undefined> {

Logger.debug(`Fetch milestones - enter`, this.id);

const { query, remote, schema } = await this.ensure();

const { data } = await query<FileContentResponse>({

query: schema.GetFileContent,

variables: {

owner: remote.owner,

name: remote.repositoryName,

expression: `${sha}:${file}`

}

});

if (!data.repository?.object.text) {

return undefined;

}

return data.repository.object.text.split('\n').slice(lineStart - 1, lineEnd).join('\n');

}

async getIssues(page?: number, queryString?: string): Promise<IssueData | undefined> {

try {

Logger.debug(`Fetch issues with query - enter`, this.id);

const { query, schema } = await this.ensure();

const { data } = await query<IssuesSearchResponse>({

query: schema.Issues,

variables: {

query: `${queryString} type:issue`,

},

});

Logger.debug(`Fetch issues with query - done`, this.id);

const issues: Issue[] = [];

if (data && data.search.edges) {

await Promise.all(data.search.edges.map(async raw => {

if (raw.node.id) {

issues.push(await parseGraphQLIssue(raw.node, this));

}

}));

}

return {

items: issues,

hasMorePages: data.search.pageInfo.hasNextPage,

totalCount: data.search.issueCount

};

} catch (e) {

Logger.error(`Unable to fetch issues with query: ${e}`, this.id);

return;

}

}

private async _getMaxItem(isIssue: boolean): Promise<number | undefined> {

try {

Logger.debug(`Fetch max ${isIssue ? 'issue' : 'pull request'} - enter`, this.id);

const { query, remote, schema } = await this.ensure();

const { data } = await query<MaxIssueResponse>({

query: isIssue ? schema.MaxIssue : schema.MaxPullRequest,

variables: {

owner: remote.owner,

name: remote.repositoryName,

},

});

Logger.debug(`Fetch max ${isIssue ? 'issue' : 'pull request'} - done`, this.id);

if (data?.repository && data.repository.issues.edges.length === 1) {

return data.repository.issues.edges[0].node.number;

}

return;

} catch (e) {

Logger.error(`Unable to fetch ${isIssue ? 'issues' : 'pull requests'} with query: ${e}`, this.id);

return;

}

}

async getMaxIssue(): Promise<number | undefined> {

return this._getMaxItem(true);

}

async getMaxPullRequest(): Promise<number | undefined> {

return this._getMaxItem(false);

}

/**

* Returns the highest known issue or pull request number for this repository.

* Issues and pull requests share the same number sequence on GitHub, so the

* larger of the two latest items is an upper bound for any valid number.

* Result is cached for a short TTL to avoid extra round-trips.

*/

private async getCachedMaxItemNumber(forceRefresh: boolean = false): Promise<number | undefined> {

const now = Date.now();

if (!forceRefresh && this._maxItemNumberCache && (now - this._maxItemNumberCache.fetchedAt) < GitHubRepository.MAX_ITEM_NUMBER_TTL_MS) {

return this._maxItemNumberCache.value;

}

if (this._maxItemNumberPromise) {

return this._maxItemNumberPromise;

}

this._maxItemNumberPromise = (async () => {

const [maxIssue, maxPr] = await Promise.all([this._getMaxItem(true), this._getMaxItem(false)]);

const max = Math.max(maxIssue ?? 0, maxPr ?? 0);

if (max > 0) {

this._maxItemNumberCache = { value: max, fetchedAt: Date.now() };

return max;

}

return undefined;

})();

try {

return await this._maxItemNumberPromise;

} finally {

this._maxItemNumberPromise = undefined;