@gitkraken/core-gitlens 0.6.0 → 0.7.1

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

@@ -1,478 +1,391 @@
-import { CancellationError } from '../../../utils/cancellation.js';
-import { md5 } from '../../../utils/crypto.js';
-import { uniqueBy } from '../../../utils/iterable.js';
-import { batchResults, flatSettled, nonnullSettled } from '../../../utils/promise.js';
-import { toTokenWithInfo } from '../authentication/models.js';
-import { toCollectionScopeFailure } from '../collectionMetadata.js';
-import { GitCloudHostIntegrationId } from '../constants.js';
-import { GitHostIntegration } from '../models/gitHostIntegration.js';
-import { fromProviderPullRequest, getProviderPullRequestIdentity, providersMetadata, PullRequestFilter, toProviderPullRequestStates, } from './models.js';
-import { collectProviderPagedResult, flatSettledOrThrow, mergeCollectionMetadata, parsePageCursor, toPageCursor, } from './utils/providerPaging.js';
-const metadata = providersMetadata[GitCloudHostIntegrationId.Bitbucket];
-const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
-export class BitbucketIntegration extends GitHostIntegration {
-    authProvider = authProvider;
-    id = GitCloudHostIntegrationId.Bitbucket;
-    key = this.id;
-    name = 'Bitbucket';
-    get domain() {
-        return metadata.domain;
-    }
-    get apiBaseUrl() {
-        return 'https://api.bitbucket.org/2.0';
-    }
-    async mergeProviderPullRequest(session, pr, options) {
-        const api = await this.getProvidersApi();
-        return api.mergePullRequest(toTokenWithInfo(this.id, session), pr, {
-            mergeMethod: options?.mergeMethod,
-        });
-    }
-    async getRepoInfo(repo) {
-        const api = await this.getProvidersApi();
-        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
-        const session = await this.resolveReadSession(repo.connectionId, undefined);
-        if (session == null)
-            return undefined;
-        return api.getRepo(toTokenWithInfo(this.id, session), repo.owner, repo.name, repo.project, {
-            baseUrl: this.apiBaseUrl,
-        });
-    }
-    async getProviderAccountForCommit(session, repo, rev, options) {
-        return (await this.authenticationService.apis.bitbucket)?.getAccountForCommit(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, rev, this.apiBaseUrl, {
-            avatarSize: options?.avatarSize,
-        });
-    }
-    async getProviderAccountForEmail(_session, _repo, _email, _options) {
-        return Promise.resolve(undefined);
-    }
-    async getProviderDefaultBranch(session, repo, cancellation) {
-        return (await this.authenticationService.apis.bitbucket)?.getDefaultBranch(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, { baseUrl: this.apiBaseUrl }, cancellation);
-    }
-    async getProviderLinkedIssueOrPullRequest(session, repo, { id }, type) {
-        return (await this.authenticationService.apis.bitbucket)?.getIssueOrPullRequest(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, id, this.apiBaseUrl, {
-            type: type,
-        });
-    }
-    async getProviderIssue(session, repo, id) {
-        return (await this.authenticationService.apis.bitbucket)?.getIssue(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, id, this.apiBaseUrl);
-    }
-    async getProviderPullRequestForBranch(session, repo, branch, _options) {
-        return (await this.authenticationService.apis.bitbucket)?.getPullRequestForBranch(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, branch, this.apiBaseUrl);
-    }
-    async getProviderPullRequestForCommit(session, repo, rev) {
-        return (await this.authenticationService.apis.bitbucket)?.getPullRequestForCommit(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, rev, this.apiBaseUrl);
-    }
-    async getProviderRepositoryMetadata(session, repo, cancellation) {
-        return (await this.authenticationService.apis.bitbucket)?.getRepositoryMetadata(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, { baseUrl: this.apiBaseUrl }, cancellation);
-    }
-    _accounts;
-    async getProviderCurrentAccount(session) {
-        const { accessToken } = session;
-        this._accounts ??= new Map();
-        const cachedAccount = this._accounts.get(accessToken);
-        if (cachedAccount == null) {
-            const api = await this.getProvidersApi();
-            const user = await api.getCurrentUser(toTokenWithInfo(this.id, session));
-            this._accounts.set(accessToken, user
-                ? {
-                    provider: this,
-                    id: user.id,
-                    name: user.name ?? undefined,
-                    email: user.email ?? undefined,
-                    avatarUrl: user.avatarUrl ?? undefined,
-                    username: user.username ?? undefined,
-                }
-                : undefined);
-        }
-        return this._accounts.get(accessToken);
-    }
-    _workspaces;
-    async getProviderResourcesForCurrentUser(session, force = false) {
-        this._workspaces ??= new Map();
-        const { accessToken } = session;
-        const cachedResources = this._workspaces.get(accessToken);
-        if (cachedResources != null && !force)
-            return cachedResources;
-        const api = await this.getProvidersApi();
-        const resources = await api.getBitbucketResourcesForCurrentUser(toTokenWithInfo(this.id, session));
-        if (resources == null)
-            return undefined;
-        const values = resources.values.map(r => ({ ...r, key: r.id, name: r.name ?? r.slug }));
-        const metadata = mergeCollectionMetadata(resources.metadata, resources.paging?.truncated === true ? { completeness: 'partial' } : undefined);
-        const result = {
-            values: values,
-            ...(metadata != null ? { metadata: metadata } : {}),
-        };
-        // A partial workspace prefix is useful to the current read but must not become authoritative cache state:
-        // a transient page-2 failure must be retried on the next call rather than hiding every later workspace
-        // until disconnect.
-        if (metadata == null || metadata.completeness === 'complete') {
-            this._workspaces.set(accessToken, result);
-        }
-        return result;
-    }
-    async getProviderOrganizationsForUser(session) {
-        const workspaces = await this.getProviderResourcesForCurrentUser(session);
-        if (workspaces == null)
-            return undefined;
-        return {
-            values: workspaces.values.map(w => ({
-                id: w.id,
-                providerId: this.id,
-                name: w.slug,
-                url: `https://bitbucket.org/${w.slug}`,
-            })),
-            ...(workspaces.metadata != null ? { metadata: workspaces.metadata } : {}),
-        };
-    }
-    async getProviderRepositoriesForOrg(session, org, options) {
-        const api = await this.getProvidersApi();
-        return api.getReposForBitbucketWorkspace(toTokenWithInfo(this.id, session), org, {
-            cursor: options?.cursor,
-        });
-    }
-    async searchProviderMyPullRequests(session, repos, _cancellation, options) {
-        if (repos != null) {
-            // TODO: implement repos version
-            return undefined;
-        }
-        const state = options?.state;
-        const states = toProviderPullRequestStates(state);
-        const api = await this.getProvidersApi();
-        if (!api) {
-            return undefined;
-        }
-        const user = await this.getProviderCurrentAccount(session);
-        // `user.id` feeds both the authored workspace reads and the reviewer BBQL clause; guard on it so we
-        // never issue requests/queries with an undefined uuid. `username` isn't used here, so don't gate on it.
-        if (user?.id == null)
-            return undefined;
-        const workspacesResult = await this.getProviderResourcesForCurrentUser(session);
-        if (workspacesResult == null)
-            return undefined;
-        const workspaces = workspacesResult.values;
-        if (workspaces.length === 0)
-            return [];
-        const authoredPrs = workspaces.map(async (ws) => {
-            const prs = await api.getBitbucketPullRequestsAuthoredByUserForWorkspace(toTokenWithInfo(this.id, session), user.id, ws.slug, { states: states });
-            return prs?.data.map(pr => fromProviderPullRequest(pr, this));
-        });
-        if (!options?.includeReviewRequested) {
-            return [
-                ...uniqueBy(await flatSettled(authoredPrs), pr => pr.url, (orig, _cur) => orig),
-            ];
-        }
-        // Bitbucket's reviewing PRs require a repo-scoped BBQL query; keep that sweep opt-in so the default
-        // "my pull requests" feed stays aligned with backends that only expose authored PRs.
-        const stateClause = state === 'closed'
-            ? '(state="DECLINED" OR state="SUPERSEDED")'
-            : state === 'merged'
-                ? 'state="MERGED"'
-                : state === 'all'
-                    ? undefined
-                    : 'state="OPEN"';
-        const workspaceRepos = await this.getWorkspaceRepoInputs();
-        if (workspaceRepos.length === 0) {
-            return [
-                ...uniqueBy(await flatSettled(authoredPrs), pr => pr.url, (orig, _cur) => orig),
-            ];
-        }
-        const reviewerClause = `reviewers.uuid="${user.id}"`;
-        const reviewingPrs = api
-            .getPullRequestsForRepos(toTokenWithInfo(this.id, session), workspaceRepos, {
-            query: stateClause ? `${stateClause} AND ${reviewerClause}` : reviewerClause,
-        })
-            .then(r => r.values?.map(pr => fromProviderPullRequest(pr, this)));
-        return [
-            ...uniqueBy(await flatSettled([...authoredPrs, reviewingPrs]), pr => pr.url, (orig, _cur) => orig),
-        ];
-    }
-    async getProviderMyPullRequestsForUser(session, options) {
-        const api = await this.getProvidersApi();
-        const user = await this.getProviderCurrentAccount(session);
-        if (user?.id == null)
-            return undefined;
-        const workspacesResult = await this.getProviderResourcesForCurrentUser(session);
-        if (workspacesResult == null)
-            return undefined;
-        const workspaces = workspacesResult.values;
-        if (workspaces.length === 0) {
-            const incomplete = workspacesResult.metadata != null && workspacesResult.metadata.completeness !== 'complete';
-            return {
-                values: [],
-                paging: { cursor: '{}', more: false, truncated: incomplete || undefined },
-                ...(workspacesResult.metadata != null ? { metadata: workspacesResult.metadata } : {}),
-            };
-        }
-        // Account-wide "my PRs" for Bitbucket = the user's authored PRs across every workspace they belong to,
-        // plus the PRs they've been requested to review. Bitbucket's cross-workspace read is per-workspace and
-        // numbered-page, so drain each workspace fully (bounded by a defensive backstop) and concatenate.
-        // There's no single cross-workspace cursor, so the aggregate is one page; `truncated` is set when a
-        // workspace hit the backstop with more pages left, or when a workspace's read was dropped by a failure.
-        const states = toProviderPullRequestStates(options?.state);
-        const requested = options?.filters?.length ? new Set(options.filters) : undefined;
-        const wantAuthored = requested == null || requested.has(PullRequestFilter.Author);
-        const wantReviewRequested = requested?.has(PullRequestFilter.ReviewRequested) ?? options?.includeReviewRequested === true;
-        const maxPagesPerWorkspace = 20;
-        let truncated = workspacesResult.metadata != null && workspacesResult.metadata.completeness !== 'complete';
-        // Structured per-scope failures from BOTH the authored and reviewer slices. A rejected scope is recorded
-        // here (never re-thrown) so successful sibling workspaces/repos survive and the ProviderBackend facade
-        // maps each failure to an actionable warning + `fetchFailed` (auth/rate-limit failures still drive
-        // recovery through their warning kind, matching the SDK's own collect-across-scopes model).
-        const failures = [];
-        let aggregateMetadata = workspacesResult.metadata;
-        const absorbCollectionResult = (result) => {
-            aggregateMetadata = mergeCollectionMetadata(aggregateMetadata, result.metadata);
-            if (result.truncated || (result.metadata != null && result.metadata.completeness !== 'complete')) {
-                truncated = true;
-            }
-        };
-        const settled = wantAuthored
-            ? await Promise.allSettled(workspaces.map(async (ws) => {
-                return collectProviderPagedResult(async (cursor) => {
-                    const result = await api.getBitbucketPullRequestsAuthoredByUserForWorkspace(toTokenWithInfo(this.id, session), user.id, ws.slug, { states: states, page: parsePageCursor(cursor) });
-                    if (result == null)
-                        return undefined;
-                    return {
-                        values: result.data,
-                        paging: {
-                            more: result.hasMore,
-                            cursor: result.hasMore && result.nextPage != null
-                                ? toPageCursor(result.nextPage)
-                                : '{}',
-                        },
-                    };
-                }, maxPagesPerWorkspace, { providerId: this.id, resourceId: ws.slug });
-            }))
-            : [];
-        const prsByIdentity = new Map();
-        let unkeyedPullRequest = 0;
-        const addPullRequest = (pr) => {
-            const key = getProviderPullRequestIdentity(pr) ?? `unkeyed:${unkeyedPullRequest++}`;
-            if (!prsByIdentity.has(key)) {
-                prsByIdentity.set(key, pr);
-            }
-        };
-        // `allSettled` preserves order, so `settled[i]` is `workspaces[i]`. A rejected workspace becomes a
-        // structured failure (attributed to its slug) instead of a generic truncation or a re-throw, preserving
-        // every sibling workspace's authored PRs.
-        settled.forEach((outcome, i) => {
-            if (outcome.status !== 'fulfilled') {
-                failures.push(this.toWorkspaceFailure(workspaces[i].slug, outcome.reason));
-                return;
-            }
-            absorbCollectionResult(outcome.value);
-            for (const pr of outcome.value.values) {
-                addPullRequest(pr);
-            }
-        });
-        // Bitbucket's account-wide (per-workspace) endpoint returns authored PRs only, and the SDK exposes no
-        // workspace-level reviewer query — only a repo-scoped one. Adding the reviewer slice therefore requires
-        // draining every workspace's full repo list and then a per-repo `getPullRequestsForRepo` with `reviewerId`
-        // (O(workspaces × repos) requests), so keep it opt-in: gate it on `includeReviewRequested` so the default
-        // sweep matches the gkcli baseline (authored PRs only, no reviewer fan-out) and a caller pays that cost
-        // only when it deliberately asks for review-requested PRs.
-        if (wantReviewRequested) {
-            // Enumerate the account's repos by draining each resolved workspace's repository list, then drain the
-            // real per-repo paged `getPullRequestsForRepo` for each repo with `reviewerId`, so review-requested PRs
-            // aren't bounded to the currently-open remotes and a reviewer PR past the first page isn't dropped.
-            // Structured per-scope failures are collected as CollectionScopeFailure so the ProviderBackend facade
-            // maps them to actionable warnings (Step 3).
-            const maxReposPagesPerWorkspace = 20;
-            const maxPrPagesPerRepo = 20;
-            // Bound concurrency: workspaces are few, so process them concurrently, but drain each workspace's repos
-            // in a bounded batch rather than an unbounded Promise.all over every repo in every workspace.
-            const repoBatchSize = 5;
-            await Promise.all(workspaces.map(async (ws) => {
-                let repos;
-                try {
-                    const discovered = await collectProviderPagedResult(cursor => api.getReposForBitbucketWorkspace(toTokenWithInfo(this.id, session), ws.slug, {
-                        cursor: cursor,
-                    }), maxReposPagesPerWorkspace, { providerId: this.id, resourceId: ws.slug });
-                    repos = discovered.values;
-                    absorbCollectionResult(discovered);
-                }
-                catch (ex) {
-                    // Record the workspace as a structured failure and keep going: the failure metadata drives
-                    // the warning + `fetchFailed` + incompleteness for every kind (auth/rate-limit stay
-                    // actionable via their warning kind), so sibling workspaces' repos are still drained.
-                    failures.push(this.toWorkspaceFailure(ws.slug, ex));
-                    return;
-                }
-                const drained = await batchResults(repos, repoBatchSize, async (repo) => {
-                    const reviewing = await collectProviderPagedResult(cursor => api.getPullRequestsForRepo(toTokenWithInfo(this.id, session), { namespace: repo.namespace, name: repo.name }, { reviewerId: user.id, states: states, cursor: cursor }), maxPrPagesPerRepo, {
-                        providerId: this.id,
-                        resourceId: ws.slug,
-                        repositoryId: `${repo.namespace}/${repo.name}`,
-                    });
-                    return { repo: repo, reviewing: reviewing };
-                });
-                for (let i = 0; i < drained.length; i++) {
-                    const outcome = drained[i];
-                    if (outcome.status !== 'fulfilled') {
-                        const repo = repos[i];
-                        failures.push(this.toRepositoryFailure(`${repo?.namespace ?? ws.slug}/${repo?.name ?? 'unknown'}`, outcome.reason));
-                        continue;
-                    }
-                    const { reviewing } = outcome.value;
-                    absorbCollectionResult(reviewing);
-                    for (const pr of reviewing.values) {
-                        addPullRequest(pr);
-                    }
-                }
-            }));
-        }
-        // Every slice that ran (authored workspaces always, reviewer workspaces/repos when opted in) records its
-        // per-scope rejections as structured failures instead of re-throwing: re-throwing would discard every
-        // successful sibling's PRs. Auth/rate-limit failures stay actionable through the metadata (the facade maps
-        // kind `authentication` → an `auth` warning, `rate-limit` → a `rate-limit` warning) while the survivors are
-        // returned with `fetchFailed`.
-        const metadata = mergeCollectionMetadata(failures.length > 0 ? { completeness: 'partial', failures: failures } : undefined, aggregateMetadata);
-        return {
-            values: [...prsByIdentity.values()],
-            paging: { cursor: '{}', more: false, truncated: truncated || undefined },
-            metadata: metadata,
-        };
-    }
-    /** Classifies a caught workspace-scope error into a structured {@link CollectionScopeFailure}. */
-    toWorkspaceFailure(workspaceSlug, ex) {
-        return toCollectionScopeFailure({ providerId: this.id, resourceId: workspaceSlug }, ex);
-    }
-    /** Classifies a caught repository-scope error into a structured {@link CollectionScopeFailure}. */
-    toRepositoryFailure(repositoryId, ex) {
-        return toCollectionScopeFailure({ providerId: this.id, repositoryId: repositoryId }, ex);
-    }
-    async searchProviderPullRequests(session, searchQuery, repos, cancellation, options) {
-        if (cancellation?.aborted)
-            throw new CancellationError();
-        const api = await this.getProvidersApi();
-        if (!api)
-            return undefined;
-        const workspaceRepos = repos != null
-            ? repos.map(r => ({ name: r.name, namespace: r.owner }))
-            : await this.getWorkspaceRepoInputs();
-        if (cancellation?.aborted)
-            throw new CancellationError();
-        // An explicitly-empty `repos` means "search these zero repos" -> no results; reserve `undefined`
-        // ("scope couldn't be determined") for when no repos were requested and none were discovered.
-        if (workspaceRepos.length === 0)
-            return repos != null ? [] : undefined;
-        const token = toTokenWithInfo(this.id, session);
-        const states = toProviderPullRequestStates(options?.include);
-        const providerPullRequests = await flatSettledOrThrow(workspaceRepos.map(async (repo) => {
-            const result = await collectProviderPagedResult(cursor => {
-                if (cancellation?.aborted)
-                    throw new CancellationError();
-                return api.getPullRequestsForRepo(token, repo, {
-                    cursor: cursor,
-                    query: searchQuery,
-                    states: states,
-                });
-            });
-            return result.values;
-        }));
-        if (cancellation?.aborted)
-            throw new CancellationError();
-        return providerPullRequests.map(pr => fromProviderPullRequest(pr, this));
-    }
-    async getWorkspaceRepoInputs() {
-        const remotes = await this.ctx.repositories.getOpenRemotes();
-        const inputs = await nonnullSettled(remotes.map(async (r) => {
-            const integration = await this.authenticationService.getByRemote(r);
-            if (integration !== this)
-                return undefined;
-            // Use the remote provider's parsing rather than splitting `r.path`, so adornments like a
-            // trailing `.git` or extra path segments don't leak into the namespace/name.
-            const namespace = r.provider?.owner;
-            const name = r.provider?.repoName;
-            return namespace != null && name != null ? { name: name, namespace: namespace } : undefined;
-        }));
-        // Dedupe: a repo with multiple remotes (e.g. `origin` + `upstream`) can map to the same input,
-        // which would otherwise fetch and return the same PRs more than once.
-        return [...new Map(inputs.map(i => [`${i.namespace}/${i.name}`, i])).values()];
-    }
-    async searchProviderMyIssues(session, repos) {
-        if (repos == null || repos.length === 0)
-            return undefined;
-        const user = await this.getProviderCurrentAccount(session);
-        if (user?.username == null)
-            return undefined;
-        const api = await this.authenticationService.apis.bitbucket;
-        if (!api)
-            return undefined;
-        const issueResult = await flatSettled(repos.map(repo => {
-            return api.getUsersIssuesForRepo(this, toTokenWithInfo(this.id, session), user.id, repo.owner, repo.name, this.apiBaseUrl);
-        }));
-        return issueResult;
-    }
-    /**
-     * Bitbucket is not an issue provider on the ProviderBackend surface: Bitbucket Cloud deprecated its issue
-     * tracker in favor of dedicated issue integrations (e.g. Jira). The legacy per-repo `getUsersIssuesForRepo`
-     * client is retained only for autolink/hover enrichment, not for the ProviderBackend issue reads, so the
-     * facade reports issues as unsupported rather than serving a deprecated, partial source.
-     */
-    get supportsIssues() {
-        return false;
-    }
-    storagePrefix = 'bitbucket';
-    async providerOnConnect() {
-        if (this._session == null)
-            return;
-        const accountStorageKey = md5(this._session.accessToken);
-        const storedAccount = this.ctx.storage.get(`${this.storagePrefix}:${accountStorageKey}:account`);
-        const storedWorkspaces = this.ctx.storage.get(`${this.storagePrefix}:${accountStorageKey}:workspaces`);
-        let account = storedAccount?.data ? { ...storedAccount.data, provider: this } : undefined;
-        const storedWorkspacesData = storedWorkspaces?.data;
-        let workspaces;
-        if (!Array.isArray(storedWorkspacesData) &&
-            Array.isArray(storedWorkspacesData?.values) &&
-            (storedWorkspacesData.metadata == null || storedWorkspacesData.metadata.completeness === 'complete')) {
-            workspaces = {
-                values: storedWorkspacesData.values.map((o) => ({ ...o })),
-                ...(storedWorkspacesData.metadata != null ? { metadata: storedWorkspacesData.metadata } : {}),
-            };
-        }
-        if (storedAccount == null) {
-            account = await this.getProviderCurrentAccount(this._session);
-            if (account != null) {
-                // Clear all other stored workspaces and repositories and accounts when our session changes
-                await this.ctx.storage.deleteWithPrefix(this.storagePrefix);
-                await this.ctx.storage.store(`${this.storagePrefix}:${accountStorageKey}:account`, {
-                    v: 1,
-                    timestamp: Date.now(),
-                    data: {
-                        id: account.id,
-                        name: account.name,
-                        email: account.email,
-                        avatarUrl: account.avatarUrl,
-                        username: account.username,
-                    },
-                });
-            }
-        }
-        this._accounts ??= new Map();
-        this._accounts.set(this._session.accessToken, account);
-        if (workspaces == null) {
-            const discovered = await this.getProviderResourcesForCurrentUser(this._session, true);
-            if (discovered?.metadata == null || discovered.metadata.completeness === 'complete') {
-                workspaces = discovered;
-                if (workspaces != null) {
-                    await this.ctx.storage.store(`${this.storagePrefix}:${accountStorageKey}:workspaces`, {
-                        v: 2,
-                        timestamp: Date.now(),
-                        data: workspaces,
-                    });
-                }
-            }
-        }
-        if (workspaces != null) {
-            this._workspaces ??= new Map();
-            this._workspaces.set(this._session.accessToken, workspaces);
-        }
-    }
-    providerOnDisconnect() {
-        this._accounts = undefined;
-        this._workspaces = undefined;
-    }
-}
+import { uniqueBy } from "../../../utils/iterable.js";
+import { CancellationError } from "../../../utils/cancellation.js";
+import { batchResults, flatSettled, nonnullSettled } from "../../../utils/promise.js";
+import { md5 } from "../../../utils/crypto.js";
+import "../../../git/models/pullRequest.js";
+import { toCollectionScopeFailure } from "../collectionMetadata.js";
+import "../constants.js";
+import { toTokenWithInfo } from "../authentication/models.js";
+import { collectProviderPagedResult, flatSettledOrThrow, mergeCollectionMetadata, parsePageCursor, toPageCursor } from "./utils/providerPaging.js";
+import { fromProviderPullRequest, getProviderPullRequestIdentity, providersMetadata, toProviderPullRequestStates } from "./models.js";
+import { GitHostIntegration } from "../models/gitHostIntegration.js";
+//#region ../plus/integrations/src/providers/bitbucket.ts
+const metadata = providersMetadata["bitbucket"];
+const authProvider = Object.freeze({
+	id: metadata.id,
+	scopes: metadata.scopes
+});
+var BitbucketIntegration = class extends GitHostIntegration {
+	authProvider = authProvider;
+	id = "bitbucket";
+	key = this.id;
+	name = "Bitbucket";
+	get domain() {
+		return metadata.domain;
+	}
+	get apiBaseUrl() {
+		return "https://api.bitbucket.org/2.0";
+	}
+	async mergeProviderPullRequest(session, pr, options) {
+		return (await this.getProvidersApi()).mergePullRequest(toTokenWithInfo(this.id, session), pr, { mergeMethod: options?.mergeMethod });
+	}
+	async getRepoInfo(repo) {
+		const api = await this.getProvidersApi();
+		const session = await this.resolveReadSession(repo.connectionId, void 0);
+		if (session == null) return void 0;
+		return api.getRepo(toTokenWithInfo(this.id, session), repo.owner, repo.name, repo.project, { baseUrl: this.apiBaseUrl });
+	}
+	async getProviderAccountForCommit(session, repo, rev, options) {
+		return (await this.authenticationService.apis.bitbucket)?.getAccountForCommit(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, rev, this.apiBaseUrl, { avatarSize: options?.avatarSize });
+	}
+	async getProviderAccountForEmail(_session, _repo, _email, _options) {
+		return Promise.resolve(void 0);
+	}
+	async getProviderDefaultBranch(session, repo, cancellation) {
+		return (await this.authenticationService.apis.bitbucket)?.getDefaultBranch(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, { baseUrl: this.apiBaseUrl }, cancellation);
+	}
+	async getProviderLinkedIssueOrPullRequest(session, repo, { id }, type) {
+		return (await this.authenticationService.apis.bitbucket)?.getIssueOrPullRequest(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, id, this.apiBaseUrl, { type });
+	}
+	async getProviderIssue(session, repo, id) {
+		return (await this.authenticationService.apis.bitbucket)?.getIssue(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, id, this.apiBaseUrl);
+	}
+	async getProviderPullRequestForBranch(session, repo, branch, _options) {
+		return (await this.authenticationService.apis.bitbucket)?.getPullRequestForBranch(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, branch, this.apiBaseUrl);
+	}
+	async getProviderPullRequestForCommit(session, repo, rev) {
+		return (await this.authenticationService.apis.bitbucket)?.getPullRequestForCommit(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, rev, this.apiBaseUrl);
+	}
+	async getProviderRepositoryMetadata(session, repo, cancellation) {
+		return (await this.authenticationService.apis.bitbucket)?.getRepositoryMetadata(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, { baseUrl: this.apiBaseUrl }, cancellation);
+	}
+	_accounts;
+	async getProviderCurrentAccount(session) {
+		const { accessToken } = session;
+		this._accounts ??= /* @__PURE__ */ new Map();
+		if (this._accounts.get(accessToken) == null) {
+			const user = await (await this.getProvidersApi()).getCurrentUser(toTokenWithInfo(this.id, session));
+			this._accounts.set(accessToken, user ? {
+				provider: this,
+				id: user.id,
+				name: user.name ?? void 0,
+				email: user.email ?? void 0,
+				avatarUrl: user.avatarUrl ?? void 0,
+				username: user.username ?? void 0
+			} : void 0);
+		}
+		return this._accounts.get(accessToken);
+	}
+	_workspaces;
+	async getProviderResourcesForCurrentUser(session, force = false) {
+		this._workspaces ??= /* @__PURE__ */ new Map();
+		const { accessToken } = session;
+		const cachedResources = this._workspaces.get(accessToken);
+		if (cachedResources != null && !force) return cachedResources;
+		const resources = await (await this.getProvidersApi()).getBitbucketResourcesForCurrentUser(toTokenWithInfo(this.id, session));
+		if (resources == null) return void 0;
+		const values = resources.values.map((r) => ({
+			...r,
+			key: r.id,
+			name: r.name ?? r.slug
+		}));
+		const metadata = mergeCollectionMetadata(resources.metadata, resources.paging?.truncated === true ? { completeness: "partial" } : void 0);
+		const result = {
+			values,
+			...metadata != null ? { metadata } : {}
+		};
+		if (metadata == null || metadata.completeness === "complete") this._workspaces.set(accessToken, result);
+		return result;
+	}
+	async getProviderOrganizationsForUser(session) {
+		const workspaces = await this.getProviderResourcesForCurrentUser(session);
+		if (workspaces == null) return void 0;
+		return {
+			values: workspaces.values.map((w) => ({
+				id: w.id,
+				providerId: this.id,
+				name: w.slug,
+				url: `https://bitbucket.org/${w.slug}`
+			})),
+			...workspaces.metadata != null ? { metadata: workspaces.metadata } : {}
+		};
+	}
+	async getProviderRepositoriesForOrg(session, org, options) {
+		return (await this.getProvidersApi()).getReposForBitbucketWorkspace(toTokenWithInfo(this.id, session), org, { cursor: options?.cursor });
+	}
+	async searchProviderMyPullRequests(session, repos, _cancellation, options) {
+		if (repos != null) return;
+		const state = options?.state;
+		const states = toProviderPullRequestStates(state);
+		const api = await this.getProvidersApi();
+		if (!api) return;
+		const user = await this.getProviderCurrentAccount(session);
+		if (user?.id == null) return void 0;
+		const workspacesResult = await this.getProviderResourcesForCurrentUser(session);
+		if (workspacesResult == null) return void 0;
+		const workspaces = workspacesResult.values;
+		if (workspaces.length === 0) return [];
+		const authoredPrs = workspaces.map(async (ws) => {
+			return (await api.getBitbucketPullRequestsAuthoredByUserForWorkspace(toTokenWithInfo(this.id, session), user.id, ws.slug, { states }))?.data.map((pr) => fromProviderPullRequest(pr, this));
+		});
+		if (!options?.includeReviewRequested) return [...uniqueBy(await flatSettled(authoredPrs), (pr) => pr.url, (orig, _cur) => orig)];
+		const stateClause = state === "closed" ? "(state=\"DECLINED\" OR state=\"SUPERSEDED\")" : state === "merged" ? "state=\"MERGED\"" : state === "all" ? void 0 : "state=\"OPEN\"";
+		const workspaceRepos = await this.getWorkspaceRepoInputs();
+		if (workspaceRepos.length === 0) return [...uniqueBy(await flatSettled(authoredPrs), (pr) => pr.url, (orig, _cur) => orig)];
+		const reviewerClause = `reviewers.uuid="${user.id}"`;
+		const reviewingPrs = api.getPullRequestsForRepos(toTokenWithInfo(this.id, session), workspaceRepos, { query: stateClause ? `${stateClause} AND ${reviewerClause}` : reviewerClause }).then((r) => r.values?.map((pr) => fromProviderPullRequest(pr, this)));
+		return [...uniqueBy(await flatSettled([...authoredPrs, reviewingPrs]), (pr) => pr.url, (orig, _cur) => orig)];
+	}
+	async getProviderMyPullRequestsForUser(session, options) {
+		const api = await this.getProvidersApi();
+		const user = await this.getProviderCurrentAccount(session);
+		if (user?.id == null) return void 0;
+		const workspacesResult = await this.getProviderResourcesForCurrentUser(session);
+		if (workspacesResult == null) return void 0;
+		const workspaces = workspacesResult.values;
+		if (workspaces.length === 0) return {
+			values: [],
+			paging: {
+				cursor: "{}",
+				more: false,
+				truncated: workspacesResult.metadata != null && workspacesResult.metadata.completeness !== "complete" || void 0
+			},
+			...workspacesResult.metadata != null ? { metadata: workspacesResult.metadata } : {}
+		};
+		const states = toProviderPullRequestStates(options?.state);
+		const requested = options?.filters?.length ? new Set(options.filters) : void 0;
+		const wantAuthored = requested == null || requested.has("author");
+		const wantReviewRequested = requested?.has("review-requested") ?? options?.includeReviewRequested === true;
+		const maxPagesPerWorkspace = 20;
+		let truncated = workspacesResult.metadata != null && workspacesResult.metadata.completeness !== "complete";
+		const failures = [];
+		let aggregateMetadata = workspacesResult.metadata;
+		const absorbCollectionResult = (result) => {
+			aggregateMetadata = mergeCollectionMetadata(aggregateMetadata, result.metadata);
+			if (result.truncated || result.metadata != null && result.metadata.completeness !== "complete") truncated = true;
+		};
+		const settled = wantAuthored ? await Promise.allSettled(workspaces.map(async (ws) => {
+			return collectProviderPagedResult(async (cursor) => {
+				const result = await api.getBitbucketPullRequestsAuthoredByUserForWorkspace(toTokenWithInfo(this.id, session), user.id, ws.slug, {
+					states,
+					page: parsePageCursor(cursor)
+				});
+				if (result == null) return void 0;
+				return {
+					values: result.data,
+					paging: {
+						more: result.hasMore,
+						cursor: result.hasMore && result.nextPage != null ? toPageCursor(result.nextPage) : "{}"
+					}
+				};
+			}, maxPagesPerWorkspace, {
+				providerId: this.id,
+				resourceId: ws.slug
+			});
+		})) : [];
+		const prsByIdentity = /* @__PURE__ */ new Map();
+		let unkeyedPullRequest = 0;
+		const addPullRequest = (pr) => {
+			const key = getProviderPullRequestIdentity(pr) ?? `unkeyed:${unkeyedPullRequest++}`;
+			if (!prsByIdentity.has(key)) prsByIdentity.set(key, pr);
+		};
+		settled.forEach((outcome, i) => {
+			if (outcome.status !== "fulfilled") {
+				failures.push(this.toWorkspaceFailure(workspaces[i].slug, outcome.reason));
+				return;
+			}
+			absorbCollectionResult(outcome.value);
+			for (const pr of outcome.value.values) addPullRequest(pr);
+		});
+		if (wantReviewRequested) {
+			const maxReposPagesPerWorkspace = 20;
+			const maxPrPagesPerRepo = 20;
+			const repoBatchSize = 5;
+			await Promise.all(workspaces.map(async (ws) => {
+				let repos;
+				try {
+					const discovered = await collectProviderPagedResult((cursor) => api.getReposForBitbucketWorkspace(toTokenWithInfo(this.id, session), ws.slug, { cursor }), maxReposPagesPerWorkspace, {
+						providerId: this.id,
+						resourceId: ws.slug
+					});
+					repos = discovered.values;
+					absorbCollectionResult(discovered);
+				} catch (ex) {
+					failures.push(this.toWorkspaceFailure(ws.slug, ex));
+					return;
+				}
+				const drained = await batchResults(repos, repoBatchSize, async (repo) => {
+					return {
+						repo,
+						reviewing: await collectProviderPagedResult((cursor) => api.getPullRequestsForRepo(toTokenWithInfo(this.id, session), {
+							namespace: repo.namespace,
+							name: repo.name
+						}, {
+							reviewerId: user.id,
+							states,
+							cursor
+						}), maxPrPagesPerRepo, {
+							providerId: this.id,
+							resourceId: ws.slug,
+							repositoryId: `${repo.namespace}/${repo.name}`
+						})
+					};
+				});
+				for (let i = 0; i < drained.length; i++) {
+					const outcome = drained[i];
+					if (outcome.status !== "fulfilled") {
+						const repo = repos[i];
+						failures.push(this.toRepositoryFailure(`${repo?.namespace ?? ws.slug}/${repo?.name ?? "unknown"}`, outcome.reason));
+						continue;
+					}
+					const { reviewing } = outcome.value;
+					absorbCollectionResult(reviewing);
+					for (const pr of reviewing.values) addPullRequest(pr);
+				}
+			}));
+		}
+		const metadata = mergeCollectionMetadata(failures.length > 0 ? {
+			completeness: "partial",
+			failures
+		} : void 0, aggregateMetadata);
+		return {
+			values: [...prsByIdentity.values()],
+			paging: {
+				cursor: "{}",
+				more: false,
+				truncated: truncated || void 0
+			},
+			metadata
+		};
+	}
+	/** Classifies a caught workspace-scope error into a structured {@link CollectionScopeFailure}. */
+	toWorkspaceFailure(workspaceSlug, ex) {
+		return toCollectionScopeFailure({
+			providerId: this.id,
+			resourceId: workspaceSlug
+		}, ex);
+	}
+	/** Classifies a caught repository-scope error into a structured {@link CollectionScopeFailure}. */
+	toRepositoryFailure(repositoryId, ex) {
+		return toCollectionScopeFailure({
+			providerId: this.id,
+			repositoryId
+		}, ex);
+	}
+	async searchProviderPullRequests(session, searchQuery, repos, cancellation, options) {
+		if (cancellation?.aborted) throw new CancellationError();
+		const api = await this.getProvidersApi();
+		if (!api) return void 0;
+		const workspaceRepos = repos != null ? repos.map((r) => ({
+			name: r.name,
+			namespace: r.owner
+		})) : await this.getWorkspaceRepoInputs();
+		if (cancellation?.aborted) throw new CancellationError();
+		if (workspaceRepos.length === 0) return repos != null ? [] : void 0;
+		const token = toTokenWithInfo(this.id, session);
+		const states = toProviderPullRequestStates(options?.include);
+		const providerPullRequests = await flatSettledOrThrow(workspaceRepos.map(async (repo) => {
+			return (await collectProviderPagedResult((cursor) => {
+				if (cancellation?.aborted) throw new CancellationError();
+				return api.getPullRequestsForRepo(token, repo, {
+					cursor,
+					query: searchQuery,
+					states
+				});
+			})).values;
+		}));
+		if (cancellation?.aborted) throw new CancellationError();
+		return providerPullRequests.map((pr) => fromProviderPullRequest(pr, this));
+	}
+	async getWorkspaceRepoInputs() {
+		const remotes = await this.ctx.repositories.getOpenRemotes();
+		const inputs = await nonnullSettled(remotes.map(async (r) => {
+			if (await this.authenticationService.getByRemote(r) !== this) return void 0;
+			const namespace = r.provider?.owner;
+			const name = r.provider?.repoName;
+			return namespace != null && name != null ? {
+				name,
+				namespace
+			} : void 0;
+		}));
+		return [...new Map(inputs.map((i) => [`${i.namespace}/${i.name}`, i])).values()];
+	}
+	async searchProviderMyIssues(session, repos) {
+		if (repos == null || repos.length === 0) return void 0;
+		const user = await this.getProviderCurrentAccount(session);
+		if (user?.username == null) return void 0;
+		const api = await this.authenticationService.apis.bitbucket;
+		if (!api) return void 0;
+		return await flatSettled(repos.map((repo) => {
+			return api.getUsersIssuesForRepo(this, toTokenWithInfo(this.id, session), user.id, repo.owner, repo.name, this.apiBaseUrl);
+		}));
+	}
+	/**
+	* Bitbucket is not an issue provider on the ProviderBackend surface: Bitbucket Cloud deprecated its issue
+	* tracker in favor of dedicated issue integrations (e.g. Jira). The legacy per-repo `getUsersIssuesForRepo`
+	* client is retained only for autolink/hover enrichment, not for the ProviderBackend issue reads, so the
+	* facade reports issues as unsupported rather than serving a deprecated, partial source.
+	*/
+	get supportsIssues() {
+		return false;
+	}
+	storagePrefix = "bitbucket";
+	async providerOnConnect() {
+		if (this._session == null) return;
+		const accountStorageKey = md5(this._session.accessToken);
+		const storedAccount = this.ctx.storage.get(`${this.storagePrefix}:${accountStorageKey}:account`);
+		const storedWorkspaces = this.ctx.storage.get(`${this.storagePrefix}:${accountStorageKey}:workspaces`);
+		let account = storedAccount?.data ? {
+			...storedAccount.data,
+			provider: this
+		} : void 0;
+		const storedWorkspacesData = storedWorkspaces?.data;
+		let workspaces;
+		if (!Array.isArray(storedWorkspacesData) && Array.isArray(storedWorkspacesData?.values) && (storedWorkspacesData.metadata == null || storedWorkspacesData.metadata.completeness === "complete")) workspaces = {
+			values: storedWorkspacesData.values.map((o) => ({ ...o })),
+			...storedWorkspacesData.metadata != null ? { metadata: storedWorkspacesData.metadata } : {}
+		};
+		if (storedAccount == null) {
+			account = await this.getProviderCurrentAccount(this._session);
+			if (account != null) {
+				await this.ctx.storage.deleteWithPrefix(this.storagePrefix);
+				await this.ctx.storage.store(`${this.storagePrefix}:${accountStorageKey}:account`, {
+					v: 1,
+					timestamp: Date.now(),
+					data: {
+						id: account.id,
+						name: account.name,
+						email: account.email,
+						avatarUrl: account.avatarUrl,
+						username: account.username
+					}
+				});
+			}
+		}
+		this._accounts ??= /* @__PURE__ */ new Map();
+		this._accounts.set(this._session.accessToken, account);
+		if (workspaces == null) {
+			const discovered = await this.getProviderResourcesForCurrentUser(this._session, true);
+			if (discovered?.metadata == null || discovered.metadata.completeness === "complete") {
+				workspaces = discovered;
+				if (workspaces != null) await this.ctx.storage.store(`${this.storagePrefix}:${accountStorageKey}:workspaces`, {
+					v: 2,
+					timestamp: Date.now(),
+					data: workspaces
+				});
+			}
+		}
+		if (workspaces != null) {
+			this._workspaces ??= /* @__PURE__ */ new Map();
+			this._workspaces.set(this._session.accessToken, workspaces);
+		}
+	}
+	providerOnDisconnect() {
+		this._accounts = void 0;
+		this._workspaces = void 0;
+	}
+};
+//#endregion
+export { BitbucketIntegration };
+
 //# sourceMappingURL=bitbucket.js.map