@gitkraken/core-gitlens 0.3.1 → 0.4.0

package/dist/plus/integrations/providers/providersApi.js

@@ -0,0 +1,602 @@
+import ProviderApis from '@gitkraken/provider-apis';
+import { base64 } from '../../../utils/base64.js';
+import { toTokenWithInfo } from '../authentication/models.js';
+import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, IssuesCloudHostIntegrationId, } from '../constants.js';
+import { AuthenticationError, AuthenticationErrorReason, RequestClientError, RequestNotFoundError, RequestRateLimitError, } from '../errors.js';
+import { providersMetadata } from './models.js';
+const createProviderApis = ProviderApis.default ?? ProviderApis;
+export class ProvidersApi {
+    authenticationService;
+    providers;
+    constructor(authenticationService) {
+        this.authenticationService = authenticationService;
+        const http = authenticationService.ctx.http;
+        const userAgent = http.userAgent;
+        const customFetch = async ({ url, ...options }) => {
+            const response = await http.fetch(url, {
+                ...options,
+                headers: {
+                    'User-Agent': userAgent,
+                    ...options.headers,
+                },
+            });
+            return parseFetchResponseForApi(response);
+        };
+        const providerApis = createProviderApis({ request: customFetch });
+        this.providers = {
+            [GitCloudHostIntegrationId.GitHub]: {
+                ...providersMetadata[GitCloudHostIntegrationId.GitHub],
+                provider: providerApis.github,
+                getCurrentUserFn: providerApis.github.getCurrentUser.bind(providerApis.github),
+                getPullRequestsForReposFn: providerApis.github.getPullRequestsForRepos.bind(providerApis.github),
+                getPullRequestsForUserFn: providerApis.github.getPullRequestsAssociatedWithUser.bind(providerApis.github),
+                getIssuesForReposFn: providerApis.github.getIssuesForRepos.bind(providerApis.github),
+            },
+            [GitSelfManagedHostIntegrationId.CloudGitHubEnterprise]: {
+                ...providersMetadata[GitSelfManagedHostIntegrationId.CloudGitHubEnterprise],
+                provider: providerApis.github,
+                getCurrentUserFn: providerApis.github.getCurrentUser.bind(providerApis.github),
+                getPullRequestsForReposFn: providerApis.github.getPullRequestsForRepos.bind(providerApis.github),
+                getPullRequestsForUserFn: providerApis.github.getPullRequestsAssociatedWithUser.bind(providerApis.github),
+                getIssuesForReposFn: providerApis.github.getIssuesForRepos.bind(providerApis.github),
+            },
+            [GitCloudHostIntegrationId.GitLab]: {
+                ...providersMetadata[GitCloudHostIntegrationId.GitLab],
+                provider: providerApis.gitlab,
+                getRepoFn: providerApis.gitlab.getRepo.bind(providerApis.gitlab),
+                getCurrentUserFn: providerApis.gitlab.getCurrentUser.bind(providerApis.gitlab),
+                getPullRequestsForReposFn: providerApis.gitlab.getPullRequestsForRepos.bind(providerApis.gitlab),
+                getPullRequestsForRepoFn: providerApis.gitlab.getPullRequestsForRepo.bind(providerApis.gitlab),
+                getPullRequestsForUserFn: providerApis.gitlab.getPullRequestsAssociatedWithUser.bind(providerApis.gitlab),
+                getIssueFn: providerApis.gitlab.getIssue.bind(providerApis.gitlab),
+                getIssuesForReposFn: providerApis.gitlab.getIssuesForRepos.bind(providerApis.gitlab),
+                getIssuesForRepoFn: providerApis.gitlab.getIssuesForRepo.bind(providerApis.gitlab),
+                mergePullRequestFn: providerApis.gitlab.mergePullRequest.bind(providerApis.gitlab),
+            },
+            [GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted]: {
+                ...providersMetadata[GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted],
+                provider: providerApis.gitlab,
+                getCurrentUserFn: providerApis.gitlab.getCurrentUser.bind(providerApis.gitlab),
+                getPullRequestsForReposFn: providerApis.gitlab.getPullRequestsForRepos.bind(providerApis.gitlab),
+                getPullRequestsForRepoFn: providerApis.gitlab.getPullRequestsForRepo.bind(providerApis.gitlab),
+                getPullRequestsForUserFn: providerApis.gitlab.getPullRequestsAssociatedWithUser.bind(providerApis.gitlab),
+                getIssueFn: providerApis.gitlab.getIssue.bind(providerApis.gitlab),
+                getIssuesForReposFn: providerApis.gitlab.getIssuesForRepos.bind(providerApis.gitlab),
+                getIssuesForRepoFn: providerApis.gitlab.getIssuesForRepo.bind(providerApis.gitlab),
+                mergePullRequestFn: providerApis.gitlab.mergePullRequest.bind(providerApis.gitlab),
+            },
+            [GitCloudHostIntegrationId.Bitbucket]: {
+                ...providersMetadata[GitCloudHostIntegrationId.Bitbucket],
+                provider: providerApis.bitbucket,
+                getCurrentUserFn: providerApis.bitbucket.getCurrentUser.bind(providerApis.bitbucket),
+                getBitbucketResourcesForCurrentUserFn: providerApis.bitbucket.getWorkspacesForCurrentUser.bind(providerApis.bitbucket),
+                getBitbucketPullRequestsAuthoredByUserForWorkspaceFn: providerApis.bitbucket.getPullRequestsForUserAndWorkspace.bind(providerApis.bitbucket),
+                getPullRequestsForReposFn: providerApis.bitbucket.getPullRequestsForRepos.bind(providerApis.bitbucket),
+                getPullRequestsForRepoFn: providerApis.bitbucket.getPullRequestsForRepo.bind(providerApis.bitbucket),
+                mergePullRequestFn: providerApis.bitbucket.mergePullRequest.bind(providerApis.bitbucket),
+            },
+            [GitSelfManagedHostIntegrationId.BitbucketServer]: {
+                ...providersMetadata[GitSelfManagedHostIntegrationId.BitbucketServer],
+                provider: providerApis.bitbucketServer,
+                getRepoFn: providerApis.bitbucketServer.getRepo.bind(providerApis.bitbucketServer),
+                getCurrentUserFn: providerApis.bitbucketServer.getCurrentUser.bind(providerApis.bitbucketServer),
+                getBitbucketServerPullRequestsForCurrentUserFn: providerApis.bitbucketServer.getPullRequestsForCurrentUser.bind(providerApis.bitbucketServer),
+                getPullRequestsForReposFn: providerApis.bitbucketServer.getPullRequestsForRepos.bind(providerApis.bitbucketServer),
+                getPullRequestsForRepoFn: providerApis.bitbucketServer.getPullRequestsForRepo.bind(providerApis.bitbucketServer),
+                mergePullRequestFn: providerApis.bitbucketServer.mergePullRequest.bind(providerApis.bitbucketServer),
+            },
+            [GitCloudHostIntegrationId.AzureDevOps]: {
+                ...providersMetadata[GitCloudHostIntegrationId.AzureDevOps],
+                provider: providerApis.azureDevOps,
+                getRepoOfProjectFn: providerApis.azureDevOps.getRepo.bind(providerApis.azureDevOps),
+                getCurrentUserFn: providerApis.azureDevOps.getCurrentUser.bind(providerApis.azureDevOps),
+                getCurrentUserForInstanceFn: providerApis.azureDevOps.getCurrentUserForInstance.bind(providerApis.azureDevOps),
+                getAzureResourcesForUserFn: providerApis.azureDevOps.getOrgsForUser.bind(providerApis.azureDevOps),
+                getAzureProjectsForResourceFn: providerApis.azureDevOps.getAzureProjects.bind(providerApis.azureDevOps),
+                getPullRequestsForReposFn: providerApis.azureDevOps.getPullRequestsForRepos.bind(providerApis.azureDevOps),
+                getPullRequestsForRepoFn: providerApis.azureDevOps.getPullRequestsForRepo.bind(providerApis.azureDevOps),
+                getPullRequestsForAzureProjectsFn: providerApis.azureDevOps.getPullRequestsForProjects.bind(providerApis.azureDevOps),
+                getIssuesForAzureProjectFn: providerApis.azureDevOps.getIssuesForAzureProject.bind(providerApis.azureDevOps),
+                getReposForAzureProjectFn: providerApis.azureDevOps.getReposForAzureProject.bind(providerApis.azureDevOps),
+                mergePullRequestFn: providerApis.azureDevOps.mergePullRequest.bind(providerApis.azureDevOps),
+            },
+            [GitSelfManagedHostIntegrationId.AzureDevOpsServer]: {
+                ...providersMetadata[GitSelfManagedHostIntegrationId.AzureDevOpsServer],
+                provider: providerApis.azureDevOps,
+                getRepoOfProjectFn: providerApis.azureDevOps.getRepo.bind(providerApis.azureDevOps),
+                getCurrentUserFn: providerApis.azureDevOps.getCurrentUser.bind(providerApis.azureDevOps),
+                getCurrentUserForInstanceFn: providerApis.azureDevOps.getCurrentUserForInstance.bind(providerApis.azureDevOps),
+                getAzureResourcesForUserFn: providerApis.azureDevOps.getCollectionsForUser.bind(providerApis.azureDevOps),
+                getAzureProjectsForResourceFn: providerApis.azureDevOps.getAzureProjects.bind(providerApis.azureDevOps),
+                getPullRequestsForReposFn: providerApis.azureDevOps.getPullRequestsForRepos.bind(providerApis.azureDevOps),
+                getPullRequestsForRepoFn: providerApis.azureDevOps.getPullRequestsForRepo.bind(providerApis.azureDevOps),
+                getPullRequestsForAzureProjectsFn: providerApis.azureDevOps.getPullRequestsForProjects.bind(providerApis.azureDevOps),
+                getIssuesForAzureProjectFn: providerApis.azureDevOps.getIssuesForAzureProject.bind(providerApis.azureDevOps),
+                getReposForAzureProjectFn: providerApis.azureDevOps.getReposForAzureProject.bind(providerApis.azureDevOps),
+                mergePullRequestFn: providerApis.azureDevOps.mergePullRequest.bind(providerApis.azureDevOps),
+            },
+            [IssuesCloudHostIntegrationId.Jira]: {
+                ...providersMetadata[IssuesCloudHostIntegrationId.Jira],
+                provider: providerApis.jira,
+                getCurrentUserForResourceFn: providerApis.jira.getCurrentUserForResource.bind(providerApis.jira),
+                getJiraResourcesForCurrentUserFn: providerApis.jira.getJiraResourcesForCurrentUser.bind(providerApis.jira),
+                getJiraProjectsForResourcesFn: providerApis.jira.getJiraProjectsForResources.bind(providerApis.jira),
+                getIssueFn: providerApis.jira.getIssue.bind(providerApis.jira),
+                getIssuesForProjectFn: providerApis.jira.getIssuesForProject.bind(providerApis.jira),
+                getIssuesForResourceForCurrentUserFn: providerApis.jira.getIssuesForResourceForCurrentUser.bind(providerApis.jira),
+            },
+            [IssuesCloudHostIntegrationId.Linear]: {
+                ...providersMetadata[IssuesCloudHostIntegrationId.Linear],
+                provider: providerApis.linear,
+                getIssueFn: providerApis.linear.getIssue.bind(providerApis.linear),
+                getIssuesForCurrentUserFn: providerApis.linear.getIssuesForCurrentUser.bind(providerApis.linear),
+                getLinearOrganizationFn: providerApis.linear.getLinearOrganization.bind(providerApis.linear),
+                getLinearTeamsForCurrentUserFn: providerApis.linear.getTeamsForCurrentUser.bind(providerApis.linear),
+            },
+            [IssuesCloudHostIntegrationId.Trello]: {
+                ...providersMetadata[IssuesCloudHostIntegrationId.Trello],
+                provider: providerApis.trello,
+            },
+        };
+    }
+    getScopesForProvider(providerId) {
+        return this.providers[providerId]?.scopes;
+    }
+    getProviderDomain(providerId) {
+        return this.providers[providerId]?.domain;
+    }
+    getProviderPullRequestsPagingMode(providerId) {
+        return this.providers[providerId]?.pullRequestsPagingMode;
+    }
+    getProviderIssuesPagingMode(providerId) {
+        return this.providers[providerId]?.issuesPagingMode;
+    }
+    providerSupportsPullRequestFilters(providerId, filters) {
+        return (this.providers[providerId]?.supportedPullRequestFilters != null &&
+            filters.every(filter => this.providers[providerId]?.supportedPullRequestFilters?.includes(filter)));
+    }
+    providerSupportsIssueFilters(providerId, filters) {
+        return (this.providers[providerId]?.supportedIssueFilters != null &&
+            filters.every(filter => this.providers[providerId]?.supportedIssueFilters?.includes(filter)));
+    }
+    isRepoIdsInput(input) {
+        return (input != null &&
+            Array.isArray(input) &&
+            input.every((id) => typeof id === 'string' || typeof id === 'number'));
+    }
+    async getProviderToken(provider, options) {
+        const providerDescriptor = { domain: provider.domain, scopes: provider.scopes };
+        try {
+            const authProvider = await this.authenticationService.get(provider.id);
+            const session = await authProvider.getSession(providerDescriptor, {
+                createIfNeeded: options?.createSessionIfNeeded,
+            });
+            if (session == null) {
+                return undefined;
+            }
+            return toTokenWithInfo(provider.id, session);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getAzurePATForOAuthToken(oauthToken) {
+        return base64(`PAT:${oauthToken}`);
+    }
+    async ensureProviderTokenAndFunction(tokenOptInfo, providerFn) {
+        const providerId = tokenOptInfo.providerId;
+        const provider = this.providers[providerId];
+        if (provider == null) {
+            throw new Error(`Provider with id ${providerId} not registered`);
+        }
+        if (providerId !== provider.id) {
+            throw new Error(`Provider id mismatch: expected ${providerId} but got ${provider.id}`);
+        }
+        const tokenWithInfo = tokenOptInfo?.accessToken
+            ? tokenOptInfo
+            : await this.getProviderToken(provider);
+        if (tokenWithInfo == null) {
+            throw new Error(`Not connected to provider ${providerId}`);
+        }
+        if (provider[providerFn] == null) {
+            throw new Error(`Provider with id ${providerId} does not support function: ${providerFn}`);
+        }
+        return { provider: provider, tokenWithInfo: tokenWithInfo };
+    }
+    handleProviderError(tokenWithInfo, error) {
+        const { accessToken: token, ...tokenInfo } = tokenWithInfo;
+        const providerId = tokenWithInfo.providerId;
+        const provider = this.providers[providerId];
+        if (provider == null) {
+            throw new Error(`Provider with id ${providerId} not registered`);
+        }
+        if (error?.response?.status != null) {
+            switch (error.response.status) {
+                case 404: // Not found
+                case 410: // Gone
+                case 422: // Unprocessable Entity
+                    throw new RequestNotFoundError(error);
+                case 401: // Unauthorized
+                    if (error.message?.includes('rate limit')) {
+                        let resetAt;
+                        const reset = error.response?.headers?.['x-ratelimit-reset'];
+                        if (reset != null) {
+                            resetAt = parseInt(reset, 10);
+                            if (Number.isNaN(resetAt)) {
+                                resetAt = undefined;
+                            }
+                        }
+                        throw new RequestRateLimitError(error, token, resetAt);
+                    }
+                    throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Unauthorized, error);
+                case 403: // Forbidden
+                    throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, error);
+                case 429: {
+                    // Too Many Requests
+                    let resetAt;
+                    const reset = error.response.headers?.['x-ratelimit-reset'];
+                    if (reset != null) {
+                        resetAt = parseInt(reset, 10);
+                        if (Number.isNaN(resetAt)) {
+                            resetAt = undefined;
+                        }
+                    }
+                    throw new RequestRateLimitError(error, token, resetAt);
+                }
+                default:
+                    if (error.response.status >= 400 && error.response.status < 500) {
+                        throw new RequestClientError(error);
+                    }
+            }
+        }
+        throw error;
+    }
+    async getPagedResult(args, providerFn, tokenWithInfo, cursor = '{}', isPAT = false, baseUrl) {
+        let cursorInfo;
+        try {
+            cursorInfo = JSON.parse(cursor);
+        }
+        catch {
+            cursorInfo = {};
+        }
+        const cursorValue = cursorInfo.value;
+        const cursorType = cursorInfo.type;
+        let cursorOrPage = {};
+        if (cursorType === 'page') {
+            cursorOrPage = { page: cursorValue };
+        }
+        else if (cursorType === 'cursor') {
+            cursorOrPage = { cursor: cursorValue };
+        }
+        const input = {
+            ...args,
+            ...cursorOrPage,
+        };
+        try {
+            const result = await providerFn?.(input, {
+                token: tokenWithInfo.accessToken,
+                isPAT: isPAT,
+                baseUrl: baseUrl,
+            });
+            if (result == null) {
+                return { values: [] };
+            }
+            const hasMore = result.pageInfo?.hasNextPage ?? false;
+            let nextCursor = '{}';
+            if (result.pageInfo?.endCursor != null) {
+                nextCursor = JSON.stringify({ value: result.pageInfo?.endCursor, type: 'cursor' });
+            }
+            else if (result.pageInfo?.nextPage != null) {
+                nextCursor = JSON.stringify({ value: result.pageInfo?.nextPage, type: 'page' });
+            }
+            return {
+                values: result.data,
+                paging: {
+                    cursor: nextCursor,
+                    more: hasMore,
+                },
+            };
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getRepo(tokenOptInfo, owner, name, project, options) {
+        const providerId = tokenOptInfo.providerId;
+        if (providerId === GitCloudHostIntegrationId.AzureDevOps && project != null) {
+            const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getRepoOfProjectFn');
+            const token = tokenWithInfo.accessToken;
+            try {
+                const result = await provider['getRepoOfProjectFn']?.({ namespace: owner, name: name, project: project }, { token: token, isPAT: options?.isPAT, baseUrl: options?.baseUrl });
+                return result?.data;
+            }
+            catch (e) {
+                return this.handleProviderError(tokenWithInfo, e);
+            }
+        }
+        else {
+            const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getRepoFn');
+            const token = tokenWithInfo.accessToken;
+            try {
+                const result = await provider['getRepoFn']?.({ namespace: owner, name: name, project: project }, { token: token, isPAT: options?.isPAT, baseUrl: options?.baseUrl });
+                return result?.data;
+            }
+            catch (e) {
+                return this.handleProviderError(tokenWithInfo, e);
+            }
+        }
+    }
+    async getCurrentUser(tokenOptInfo, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getCurrentUserFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getCurrentUserFn?.({}, { token: token, isPAT: options?.isPAT, baseUrl: options?.baseUrl }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getCurrentUserForInstance(tokenOptInfo, namespace, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getCurrentUserForInstanceFn');
+        const token = tokenWithInfo.accessToken;
+        return (await provider.getCurrentUserForInstanceFn?.({ namespace: namespace }, { token: token, isPAT: options?.isPAT, baseUrl: options?.baseUrl }))?.data;
+    }
+    async getCurrentUserForResource(tokenOptInfo, resourceId, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getCurrentUserForResourceFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getCurrentUserForResourceFn?.({ resourceId: resourceId }, { token: token, isPAT: options?.isPAT, baseUrl: options?.baseUrl }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getJiraResourcesForCurrentUser(tokenOptInfo) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getJiraResourcesForCurrentUserFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getJiraResourcesForCurrentUserFn?.({ token: token }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getLinearOrganization(tokenOptInfo) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getLinearOrganizationFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            const x = await provider.getLinearOrganizationFn?.({ token: token });
+            const y = x?.data;
+            return y;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getLinearTeamsForCurrentUser(tokenOptInfo) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getLinearTeamsForCurrentUserFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getLinearTeamsForCurrentUserFn?.({ token: token }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getAzureResourcesForUser(tokenOptInfo, userId, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getAzureResourcesForUserFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getAzureResourcesForUserFn?.({ userId: userId }, { token: token, isPAT: options?.isPAT, baseUrl: options?.baseUrl }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getBitbucketResourcesForCurrentUser(tokenOptInfo) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getBitbucketResourcesForCurrentUserFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getBitbucketResourcesForCurrentUserFn?.({}, { token: token }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getBitbucketPullRequestsAuthoredByUserForWorkspace(tokenOptInfo, userId, workspaceSlug) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getBitbucketPullRequestsAuthoredByUserForWorkspaceFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getBitbucketPullRequestsAuthoredByUserForWorkspaceFn?.({ userId: userId, workspaceSlug: workspaceSlug }, { token: token }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getBitbucketServerPullRequestsForCurrentUser(tokenOptInfo, baseUrl) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getBitbucketServerPullRequestsForCurrentUserFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getBitbucketServerPullRequestsForCurrentUserFn?.({}, { token: token, baseUrl: baseUrl }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getJiraProjectsForResources(tokenOptInfo, resourceIds) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getJiraProjectsForResourcesFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            return (await provider.getJiraProjectsForResourcesFn?.({ resourceIds: resourceIds }, { token: token }))
+                ?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getAzureProjectsForResource(tokenOptInfo, namespace, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getAzureProjectsForResourceFn');
+        const token = tokenWithInfo.accessToken;
+        // Azure only supports PAT for this call
+        const azureToken = options?.isPAT ? token : this.getAzurePATForOAuthToken(token);
+        try {
+            return await this.getPagedResult({ namespace: namespace, ...options }, provider.getAzureProjectsForResourceFn, { ...tokenWithInfo, accessToken: azureToken }, options?.cursor, options?.isPAT, options?.baseUrl);
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getReposForAzureProject(tokenOptInfo, namespace, project, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getReposForAzureProjectFn');
+        return this.getPagedResult({ namespace: namespace, project: project, ...options }, provider.getReposForAzureProjectFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+    }
+    async getPullRequestsForRepos(tokenOptInfo, reposOrIds, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getPullRequestsForReposFn');
+        return this.getPagedResult({
+            ...(this.isRepoIdsInput(reposOrIds) ? { repoIds: reposOrIds } : { repos: reposOrIds }),
+            ...options,
+        }, provider.getPullRequestsForReposFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+    }
+    async getPullRequestsForRepo(tokenOptInfo, repo, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getPullRequestsForRepoFn');
+        return this.getPagedResult({ repo: repo, ...options }, provider.getPullRequestsForRepoFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+    }
+    async getPullRequestsForUser(tokenOptInfo, usernameOrId, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getPullRequestsForUserFn');
+        return this.getPagedResult({
+            ...(tokenWithInfo.providerId === GitCloudHostIntegrationId.Bitbucket
+                ? { userId: usernameOrId }
+                : { username: usernameOrId }),
+            ...options,
+        }, provider.getPullRequestsForUserFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+    }
+    async getPullRequestsForAzureProjects(tokenOptInfo, projects, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getPullRequestsForAzureProjectsFn');
+        const token = tokenWithInfo.accessToken;
+        // Azure only supports PAT for this call
+        const azureToken = options?.isPAT ? token : this.getAzurePATForOAuthToken(token);
+        try {
+            return (await provider.getPullRequestsForAzureProjectsFn?.({ projects: projects, ...options }, { token: azureToken, isPAT: options?.isPAT, baseUrl: options?.baseUrl }))?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async mergePullRequest(tokenOptInfo, pr, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'mergePullRequestFn');
+        const token = tokenWithInfo.accessToken;
+        const headRef = pr.refs?.head;
+        if (headRef == null)
+            return false;
+        if (provider.id === GitCloudHostIntegrationId.AzureDevOps && pr.project == null) {
+            return false;
+        }
+        try {
+            await provider.mergePullRequestFn?.({
+                pullRequest: {
+                    headRef: { oid: headRef.sha },
+                    id: pr.id,
+                    number: Number.parseInt(pr.id, 10),
+                    repository: {
+                        id: pr.repository.repo,
+                        name: pr.repository.repo,
+                        project: pr.project?.name ?? '',
+                        owner: {
+                            login: pr.repository.owner,
+                        },
+                    },
+                    version: pr.version,
+                },
+                ...options,
+            }, { token: token, isPAT: options?.isPAT, baseUrl: options?.baseUrl });
+            return true;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getIssuesForRepos(tokenOptInfo, reposOrIds, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getIssuesForReposFn');
+        return this.getPagedResult({
+            ...(this.isRepoIdsInput(reposOrIds) ? { repoIds: reposOrIds } : { repos: reposOrIds }),
+            ...options,
+        }, provider.getIssuesForReposFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+    }
+    async getIssuesForRepo(tokenOptInfo, repo, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getIssuesForRepoFn');
+        return this.getPagedResult({ repo: repo, ...options }, provider.getIssuesForRepoFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+    }
+    async getIssuesForCurrentUser(tokenOptInfo, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getIssuesForCurrentUserFn');
+        return this.getPagedResult(options, provider.getIssuesForCurrentUserFn, tokenWithInfo, options?.cursor ?? undefined, options?.isPAT, options?.baseUrl);
+    }
+    async getIssuesForAzureProject(tokenOptInfo, namespace, project, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getIssuesForAzureProjectFn');
+        return this.getPagedResult({ namespace: namespace, project: project, ...options }, provider.getIssuesForAzureProjectFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+    }
+    async getIssuesForProject(tokenOptInfo, project, resourceId, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getIssuesForProjectFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            const result = await provider.getIssuesForProjectFn?.({ projectKey: project, resourceId: resourceId, ...options }, { token: token });
+            return result?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+    async getIssuesForResourceForCurrentUser(tokenOptInfo, resourceId, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getIssuesForResourceForCurrentUserFn');
+        return this.getPagedResult({ resourceId: resourceId }, provider.getIssuesForResourceForCurrentUserFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+    }
+    async getIssue(tokenOptInfo, input, options) {
+        const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, 'getIssueFn');
+        const token = tokenWithInfo.accessToken;
+        try {
+            const result = await provider.getIssueFn?.(input, {
+                token: token,
+                isPAT: options?.isPAT,
+                baseUrl: options?.baseUrl,
+            });
+            return result?.data;
+        }
+        catch (e) {
+            return this.handleProviderError(tokenWithInfo, e);
+        }
+    }
+}
+// This is copied over from the shared provider library because the current version is not respecting the "forceIsFetch: true"
+// option in the config and our custom fetch function isn't being wrapped by the necessary fetch wrapper. Remove this once the library
+// properly wraps our custom fetch and use `forceIsFetch: true` in the config.
+async function parseFetchResponseForApi(response) {
+    const contentType = response.headers.get('content-type') || '';
+    let body;
+    // parse the response body
+    if (contentType.startsWith('application/json')) {
+        const text = await response.text();
+        body = text.trim().length > 0 ? JSON.parse(text) : null;
+    }
+    else if (contentType.startsWith('text/') || contentType === '') {
+        body = await response.text();
+    }
+    else if (contentType.startsWith('application/vnd.github.raw+json')) {
+        body = await response.arrayBuffer();
+    }
+    else {
+        throw new Error(`Unsupported content-type: ${contentType}`);
+    }
+    const result = {
+        body: body,
+        headers: Object.fromEntries(response.headers.entries()),
+        status: response.status,
+        statusText: response.statusText,
+    };
+    // throw an error if the response is not ok
+    if (!response.ok) {
+        const error = new Error(response.statusText);
+        Object.assign(error, { response: result });
+        throw error;
+    }
+    return result;
+}
+//# sourceMappingURL=providersApi.js.map