@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/src/plus/integrations/providers/pullRequestReviews.ts

@@ -1,122 +0,0 @@
-import type { GitPullRequest } from '@gitkraken/provider-apis';
-import { GitPullRequestReviewState } from '@gitkraken/provider-apis';
-import type { PullRequestReviewer } from '../../../git/models/pullRequest.js';
-import { PullRequestReviewDecision, PullRequestReviewState } from '../../../git/models/pullRequest.js';
-import { fromProviderAccount, toProviderAccount } from './accounts.js';
-
-/**
- * The GitLens-local extension of provider-apis' review shape, in two parts: a `DISMISSED` state the upstream
- * `GitPullRequestReviewState` has no member for, and the head-commit oid a review was submitted against
- * (optional, so a raw SDK review stays assignable — only the GitHub path populates it).
- *
- * Both exist for the same case: on GitHub the `dismiss stale reviews` rule flips an approval to dismissed on
- * the next push, which is exactly the "the PR moved past my review" situation the oid detects. Dropping such a
- * review instead would hand a consumer a PR out of the `reviewed-by:@me` set with no review row at all,
- * indistinguishable from never having reviewed it.
- */
-export const providerPullRequestReviewStateDismissed = 'DISMISSED' as const;
-export type ProviderPullRequestReview = Omit<NonNullable<GitPullRequest['reviews']>[number], 'state'> & {
-	state: GitPullRequestReviewState | typeof providerPullRequestReviewStateDismissed;
-	commitOid?: string;
-};
-/**
- * The review list as it travels on {@link ProviderPullRequest}: `null` when the read carried no review data at
- * all, as opposed to an empty array for a pull request nobody has reviewed.
- */
-export type ProviderPullRequestReviews = ProviderPullRequestReview[] | null;
-
-export const toProviderPullRequestReviewState = {
-	[PullRequestReviewState.Approved]: GitPullRequestReviewState.Approved,
-	[PullRequestReviewState.ChangesRequested]: GitPullRequestReviewState.ChangesRequested,
-	[PullRequestReviewState.Commented]: GitPullRequestReviewState.Commented,
-	[PullRequestReviewState.ReviewRequested]: GitPullRequestReviewState.ReviewRequested,
-	[PullRequestReviewState.Dismissed]: providerPullRequestReviewStateDismissed,
-	// A review the author started but never submitted. Visible only to that author and carrying no verdict, so
-	// it stays unmapped and is dropped by the projection.
-	[PullRequestReviewState.Pending]: null,
-};
-
-export const fromProviderPullRequestReviewState = {
-	[GitPullRequestReviewState.Approved]: PullRequestReviewState.Approved,
-	[GitPullRequestReviewState.ChangesRequested]: PullRequestReviewState.ChangesRequested,
-	[GitPullRequestReviewState.Commented]: PullRequestReviewState.Commented,
-	[GitPullRequestReviewState.ReviewRequested]: PullRequestReviewState.ReviewRequested,
-	[providerPullRequestReviewStateDismissed]: PullRequestReviewState.Dismissed,
-};
-
-export function toProviderReviews(reviewers: PullRequestReviewer[]): ProviderPullRequestReviews {
-	// Only `Pending` maps to null (see `toProviderPullRequestReviewState`), so this drops exactly the reviews
-	// that carry no verdict rather than defaulting them to `ReviewRequested` — which would report an unsubmitted
-	// draft as a pending request from that reviewer.
-	return reviewers
-		.filter(r => r.state !== PullRequestReviewState.Pending)
-		.map(reviewer => ({
-			reviewer: toProviderAccount(reviewer.reviewer),
-			state: toProviderPullRequestReviewState[reviewer.state] ?? GitPullRequestReviewState.ReviewRequested,
-			commitOid: reviewer.commitOid,
-		}));
-}
-
-export function toReviewRequests(reviews: ProviderPullRequestReviews): PullRequestReviewer[] | undefined {
-	return reviews == null
-		? undefined
-		: reviews
-				?.filter(r => r.state === GitPullRequestReviewState.ReviewRequested)
-				.map(r => ({
-					isCodeOwner: false, // TODO: Find this value, and implement in the shared lib if needed
-					reviewer: fromProviderAccount(r.reviewer),
-					state: PullRequestReviewState.ReviewRequested,
-				}));
-}
-
-export function toCompletedReviews(reviews: ProviderPullRequestReviews): PullRequestReviewer[] | undefined {
-	return reviews == null
-		? undefined
-		: reviews
-				?.filter(
-					r =>
-						r.state !== GitPullRequestReviewState.ReviewRequested &&
-						// provider-apis' own GitHub normalizer maps only its four known states, so a review it has no
-						// member for (a real `DISMISSED` one, which its `latestReviews(first: 100)` selection does
-						// return) arrives with `state: undefined` — a value its type says cannot happen. Publishing it
-						// would put an unswitchable state on `PullRequestShape.latestReviews`, and mapping back would
-						// hit `toProviderReviews`' fallback and report a dismissed review as an outstanding request.
-						// Our own GitHub path never lands here: it carries `providerPullRequestReviewStateDismissed`.
-						fromProviderPullRequestReviewState[r.state] != null,
-				)
-				.map(r => ({
-					isCodeOwner: false, // TODO: Find this value, and implement in the shared lib if needed
-					reviewer: fromProviderAccount(r.reviewer),
-					state: fromProviderPullRequestReviewState[r.state],
-					commitOid: r.commitOid,
-				}));
-}
-
-export function toProviderReviewDecision(
-	reviewDecision?: PullRequestReviewDecision,
-	reviewers?: PullRequestReviewer[],
-): GitPullRequestReviewState | null {
-	switch (reviewDecision) {
-		case PullRequestReviewDecision.Approved:
-			return GitPullRequestReviewState.Approved;
-		case PullRequestReviewDecision.ChangesRequested:
-			return GitPullRequestReviewState.ChangesRequested;
-		case PullRequestReviewDecision.ReviewRequired:
-			return GitPullRequestReviewState.ReviewRequested;
-		default: {
-			if (reviewers?.some(r => r.state === PullRequestReviewState.ReviewRequested)) {
-				return GitPullRequestReviewState.ReviewRequested;
-			} else if (reviewers?.some(r => r.state === PullRequestReviewState.Commented)) {
-				return GitPullRequestReviewState.Commented;
-			}
-			return null;
-		}
-	}
-}
-
-export const fromPullRequestReviewDecision = {
-	[GitPullRequestReviewState.Approved]: PullRequestReviewDecision.Approved,
-	[GitPullRequestReviewState.ChangesRequested]: PullRequestReviewDecision.ChangesRequested,
-	[GitPullRequestReviewState.Commented]: undefined,
-	[GitPullRequestReviewState.ReviewRequested]: PullRequestReviewDecision.ReviewRequired,
-};

package/src/plus/integrations/providers/trello.ts

@@ -1,208 +0,0 @@
-import type { Account } from '../../../git/models/author.js';
-import type { Issue, IssueShape } from '../../../git/models/issue.js';
-import type { IssueOrPullRequest, IssueOrPullRequestType } from '../../../git/models/issueOrPullRequest.js';
-import type { IssueResourceDescriptor, ResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
-import { isIssueResourceDescriptor } from '../../../git/utils/resourceDescriptor.utils.js';
-import type { IntegrationAuthenticationProviderDescriptor } from '../authentication/integrationAuthenticationProvider.js';
-import type { ProviderAuthenticationSession } from '../authentication/models.js';
-import { toTokenWithInfo } from '../authentication/models.js';
-import { IssuesCloudHostIntegrationId } from '../constants.js';
-import { IntegrationReadUnavailableError } from '../errors.js';
-import type { IssuesForProjectOptions, ProjectIssuesDrain } from '../models/issueReads.js';
-import { IssuesIntegration } from '../models/issuesIntegration.js';
-import { fromProviderIssue, providersMetadata, toIssueShape } from './models.js';
-
-const metadata = providersMetadata[IssuesCloudHostIntegrationId.Trello];
-const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
-
-/** A Trello board, surfaced as both a "resource" (org analogue) and a "project" for issue reads. */
-export interface TrelloBoardDescriptor extends IssueResourceDescriptor {}
-
-export class TrelloIntegration extends IssuesIntegration<IssuesCloudHostIntegrationId.Trello> {
-	readonly authProvider: IntegrationAuthenticationProviderDescriptor = authProvider;
-
-	override get id(): IssuesCloudHostIntegrationId.Trello {
-		return IssuesCloudHostIntegrationId.Trello;
-	}
-	protected override get key(): 'trello' {
-		return 'trello';
-	}
-	override get name(): string {
-		return metadata.name;
-	}
-	override get domain(): string {
-		return metadata.domain;
-	}
-
-	/** The Trello client requires the app key paired with the token; a session without one can't read. */
-	private appKeyFor(session: ProviderAuthenticationSession): string | undefined {
-		return session.appKey;
-	}
-
-	/**
-	 * Resolves the app key or throws — a session that authenticated but carries no app key can't read Trello,
-	 * and must be surfaced as a broken read (warning + fetchFailed) rather than an empty account.
-	 */
-	private requireAppKey(session: ProviderAuthenticationSession): string {
-		const appKey = this.appKeyFor(session);
-		if (appKey == null) {
-			throw new IntegrationReadUnavailableError(metadata.name, 'missing app key (session has no appKey)');
-		}
-		return appKey;
-	}
-
-	protected override async getProviderAccountForResource(
-		session: ProviderAuthenticationSession,
-		_resource: ResourceDescriptor,
-	): Promise<Account | undefined> {
-		const appKey = this.requireAppKey(session);
-
-		const api = await this.getProvidersApi();
-		const user = await api.getTrelloCurrentUser(toTokenWithInfo(this.id, session), appKey);
-		if (user == null) return undefined;
-
-		return {
-			provider: this,
-			id: user.id,
-			name: user.name,
-			username: user.username,
-			email: user.email,
-			avatarUrl: user.avatarUrl ?? undefined,
-		};
-	}
-
-	protected override async getProviderResourcesForUser(
-		session: ProviderAuthenticationSession,
-	): Promise<TrelloBoardDescriptor[] | undefined> {
-		const appKey = this.requireAppKey(session);
-
-		const api = await this.getProvidersApi();
-		const boards = await api.getTrelloBoardsForCurrentUser(toTokenWithInfo(this.id, session), appKey);
-		return boards?.map(b => ({ key: b.id, id: b.id, name: b.name }));
-	}
-
-	protected override getProviderProjectsForResources(
-		_session: ProviderAuthenticationSession,
-		resources: ResourceDescriptor[],
-	): Promise<TrelloBoardDescriptor[] | undefined> {
-		// Trello boards are both the resource and the project scope, so projects are the boards themselves.
-		return Promise.resolve(
-			resources.filter(isIssueResourceDescriptor).map(r => ({ key: r.key, id: r.id, name: r.name })),
-		);
-	}
-
-	protected override async getProviderIssuesForProject(
-		session: ProviderAuthenticationSession,
-		project: ResourceDescriptor,
-		options?: IssuesForProjectOptions,
-	): Promise<IssueShape[] | undefined> {
-		return (await this.getProviderIssuesForProjectWithTruncation(session, project, options))?.values;
-	}
-
-	protected override async getProviderIssuesForProjectWithTruncation(
-		session: ProviderAuthenticationSession,
-		project: ResourceDescriptor,
-		options?: IssuesForProjectOptions,
-	): Promise<ProjectIssuesDrain | undefined> {
-		// A non-issue descriptor genuinely has nothing to read (empty), but a missing app key is a broken read.
-		if (!isIssueResourceDescriptor(project)) return undefined;
-
-		const appKey = this.requireAppKey(session);
-
-		const api = await this.getProvidersApi();
-		const tokenWithInfo = toTokenWithInfo(this.id, session);
-
-		// Enrich issues with their board list names (card status), mirroring gitkraken.dev's Trello reads.
-		const lists = await api.getTrelloListsForBoard(tokenWithInfo, appKey, project.id);
-		const trelloBoardListsById = lists?.reduce<Record<string, { name: string }>>((acc, list) => {
-			acc[list.id] = { name: list.name };
-			return acc;
-		}, {});
-		const boardProject = {
-			id: project.id,
-			name: project.name,
-			resourceId: project.id,
-			resourceName: project.name,
-		};
-
-		const result = await api.getTrelloIssuesForBoard(tokenWithInfo, appKey, project.id, {
-			assigneeLogins: options?.user != null ? [options.user] : undefined,
-			trelloBoardListsById: trelloBoardListsById,
-			sort: options?.sort,
-		});
-
-		const values = result.values.flatMap(issue => {
-			const mapped = toIssueShape(issue, this);
-			return mapped == null ? [] : [{ ...mapped, project: boardProject } satisfies IssueShape];
-		});
-
-		// Trello's search caps results and reports the cap through `metadata.completeness` (partial/unknown),
-		// never a cursor. Surface that as terminal truncation; there is no next page to fetch, so retrying the
-		// same read cannot recover the omitted cards (D11).
-		const truncated = result.metadata != null && result.metadata.completeness !== 'complete';
-		return truncated
-			? { values: values, truncated: true, recovery: 'none', metadata: result.metadata }
-			: { values: values, truncated: false, metadata: result.metadata };
-	}
-
-	protected override searchProviderMyIssues(
-		_session: ProviderAuthenticationSession,
-		_resources?: ResourceDescriptor[],
-		_cancellation?: AbortSignal,
-	): Promise<IssueShape[] | undefined> {
-		// Trello has no cross-board "issues assigned to me" endpoint; issues are read per board via
-		// getIssuesForProject. Callers that need them enumerate boards first.
-		return Promise.resolve(undefined);
-	}
-
-	protected override getProviderLinkedIssueOrPullRequest(
-		_session: ProviderAuthenticationSession,
-		_resource: ResourceDescriptor,
-		_id: { id: string; key: string },
-		_type: undefined | IssueOrPullRequestType,
-	): Promise<IssueOrPullRequest | undefined> {
-		return Promise.resolve(undefined);
-	}
-
-	protected override async getProviderIssue(
-		session: ProviderAuthenticationSession,
-		resource: ResourceDescriptor,
-		id: string,
-	): Promise<Issue | undefined> {
-		if (!isIssueResourceDescriptor(resource)) return undefined;
-
-		const appKey = this.requireAppKey(session);
-		const api = await this.getProvidersApi();
-		const tokenWithInfo = toTokenWithInfo(this.id, session);
-		const lists = await api.getTrelloListsForBoard(tokenWithInfo, appKey, resource.id);
-		const trelloBoardListsById = lists?.reduce<Record<string, { name: string }>>((acc, list) => {
-			acc[list.id] = { name: list.name };
-			return acc;
-		}, {});
-
-		// Branch-association round-trips use the encoded entity identifier's stable Trello card id. Resolve that
-		// directly so large boards don't require a capped whole-board scan; keep a numeric idShort fallback so
-		// legacy/manual callers that still pass the board-local display number continue to resolve.
-		let issue = await api.getTrelloCard(tokenWithInfo, appKey, id, {
-			trelloBoardListsById: trelloBoardListsById,
-		});
-		if (issue == null && /^[0-9]+$/.test(id)) {
-			issue = (
-				await api.getTrelloIssuesForBoard(tokenWithInfo, appKey, resource.id, {
-					trelloBoardListsById: trelloBoardListsById,
-				})
-			).values.find(issue => issue.number === id);
-		}
-
-		return issue != null
-			? fromProviderIssue(issue, this, {
-					project: {
-						id: resource.id,
-						name: resource.name,
-						resourceId: resource.id,
-						resourceName: resource.name,
-					},
-				})
-			: undefined;
-	}
-}

package/src/plus/integrations/providers/utils/providerPaging.ts

@@ -1,212 +0,0 @@
-import type {
-	CollectionCompleteness,
-	CollectionMetadata,
-	CollectionOmission,
-	CollectionScopeFailure,
-} from '@gitkraken/provider-apis';
-import { isCancellationError } from '../../../../utils/cancellation.js';
-import { uniqueBy } from '../../../../utils/iterable.js';
-import { throwIfCallerContractError, toCollectionScopeFailure } from '../../collectionMetadata.js';
-import { collectionScopeKey } from '../../results.js';
-import type { ProviderApiPagedResult, ProviderHierarchyResult } from '../models.js';
-
-/**
- * Encodes an opaque numeric paging token as the `{ value, type: 'page' }` cursor the paging layer uses.
- * The value is whatever the consumer round-trips unchanged: a 1-based page number for numbered-page reads,
- * or a provider offset (e.g. Bitbucket Server's `nextPageStart`) that is never reinterpreted here.
- */
-export function toPageCursor(page: number): string {
-	return JSON.stringify({ value: page, type: 'page' });
-}
-
-/** Extracts the numeric paging token from a `{ value, type: 'page' }` cursor; undefined when absent/malformed. */
-export function parsePageCursor(cursor: string | undefined): number | undefined {
-	if (cursor == null || cursor === '{}') return undefined;
-
-	try {
-		const parsed = JSON.parse(cursor) as { value?: unknown; type?: unknown };
-		if (parsed.type === 'page' && typeof parsed.value === 'number') return parsed.value;
-	} catch {}
-
-	return undefined;
-}
-
-/** Preserves successful sibling scopes, but doesn't turn an all-scope provider failure into an empty success. */
-export function throwIfAllSettledFailed<T>(results: PromiseSettledResult<T>[]): void {
-	if (results.some(result => result.status === 'fulfilled')) return;
-
-	const rejected = results.find((result): result is PromiseRejectedResult => result.status === 'rejected');
-	if (rejected != null) throw rejected.reason;
-}
-
-export function flatSettledResultsOrThrow<T>(results: PromiseSettledResult<T[]>[]): T[] {
-	throwIfAllSettledFailed(results);
-
-	const fulfilled = results.filter((result): result is PromiseFulfilledResult<T[]> => result.status === 'fulfilled');
-	return fulfilled.flatMap(result => result.value);
-}
-
-export async function flatSettledOrThrow<T>(promises: Promise<T[]>[]): Promise<T[]> {
-	return flatSettledResultsOrThrow(await Promise.allSettled(promises));
-}
-
-/** Precedence for merged completeness: any known omission (`partial`) wins, then inability to confirm
- * (`unknown`), and only an all-`complete` set of pages stays `complete`. */
-const completenessRank: Record<CollectionCompleteness, number> = { partial: 2, unknown: 1, complete: 0 };
-
-/** A stable key for deduplicating structurally-identical scope failures accumulated across drained pages. */
-function collectionFailureKey(failure: CollectionScopeFailure): string {
-	return [failure.kind, collectionScopeKey(failure.scope), failure.message ?? ''].join(' ');
-}
-
-/**
- * A stable key for collapsing omissions accumulated across drained pages, matching the SDK's own
- * `dedupeOmissions`: kind plus scope IDs, deliberately WITHOUT `limit`/`totalCount`.
- *
- * Those counts are a re-measurement, not an identity. GitHub recomputes the match total on every request, so
- * one repository drained over several pages reports the same cap with a drifting total; keying on the total
- * would emit a near-identical warning per page ("matched 1393…", "matched 1402…") that
- * `appendDedupedWarning` cannot collapse, since the messages genuinely differ. Independently-scoped omissions
- * still stay distinct, which is the case that carries information.
- */
-function collectionOmissionKey(omission: CollectionOmission): string {
-	return [omission.kind, collectionScopeKey(omission.scope)].join(' ');
-}
-
-/**
- * Merges SDK collection metadata across drained pages. Completeness follows {@link completenessRank};
- * failures are deduplicated by kind, scope IDs, and message, and omissions are collapsed per kind and scope
- * keeping the highest reported total ({@link collectionOmissionKey}). Both preserve first-reported order.
- * Returns `undefined` when no page supplied metadata, so metadata-free providers and test doubles keep
- * behaving as before.
- */
-export function mergeCollectionMetadata(
-	base: CollectionMetadata | undefined,
-	next: CollectionMetadata | undefined,
-): CollectionMetadata | undefined {
-	if (base == null) return next;
-	if (next == null) return base;
-
-	const completeness =
-		completenessRank[next.completeness] > completenessRank[base.completeness]
-			? next.completeness
-			: base.completeness;
-
-	// First occurrence wins: a repeated failure carries no new information, since the message is part of its key.
-	const failures = [
-		...uniqueBy([...(base.failures ?? []), ...(next.failures ?? [])], collectionFailureKey, original => original),
-	];
-	// Highest total wins, so re-measuring one cap across pages collapses to a single omission holding the
-	// largest figure reported for it — the same rule the SDK applies in `createCollectionMetadata`.
-	const omissions = [
-		...uniqueBy(
-			[...(base.omissions ?? []), ...(next.omissions ?? [])],
-			collectionOmissionKey,
-			(original, current) => ((current.totalCount ?? -1) > (original.totalCount ?? -1) ? current : undefined),
-		),
-	];
-
-	return {
-		completeness: completeness,
-		...(failures.length ? { failures: failures } : {}),
-		...(omissions.length ? { omissions: omissions } : {}),
-	};
-}
-
-/**
- * Drains a provider paged fetcher into a single result while preserving enough metadata to
- * signal whether the defensive backstop interrupted the drain, and merging SDK collection metadata
- * ({@link mergeCollectionMetadata}) across the fetched pages.
- *
- * The local `truncated` flag and SDK `metadata` are distinct facts: a page-drain backstop must remain visible
- * even if every fetched page reported `complete`, and SDK incompleteness is preserved even when the drain
- * finished within its page budget.
- */
-export async function collectProviderPagedResult<T>(
-	fetch: (cursor: string | undefined) => Promise<ProviderApiPagedResult<T> | undefined>,
-	maxPages = 20,
-	scope?: CollectionScopeFailure['scope'],
-): Promise<ProviderHierarchyResult<T>> {
-	const values: NonNullable<T>[] = [];
-	let cursor: string | undefined;
-	let metadata: CollectionMetadata | undefined;
-	let truncated = false;
-
-	// Omit `metadata` entirely when no page supplied it, so a metadata-free drain stays deep-equal to its
-	// pre-metadata shape (and consumers never see an explicit `undefined`).
-	const build = (extra?: Partial<ProviderHierarchyResult<T>>): ProviderHierarchyResult<T> => {
-		const mergedMetadata = extra?.metadata ?? metadata;
-		return {
-			values: values,
-			...extra,
-			...(truncated || extra?.truncated === true ? { truncated: true } : {}),
-			...(mergedMetadata != null ? { metadata: mergedMetadata } : {}),
-		};
-	};
-
-	for (let page = 0; page < maxPages; page++) {
-		let result: ProviderApiPagedResult<T> | undefined;
-		try {
-			result = await fetch(cursor);
-		} catch (ex) {
-			if (isCancellationError(ex)) throw ex;
-
-			// A caller-contract error is not a fact about this scope, so it is never recorded as one — see
-			// `throwIfCallerContractError`. Checked alongside cancellation because both are errors that a
-			// per-scope failure would misdescribe.
-			throwIfCallerContractError(ex);
-
-			// When the caller supplied a scope, preserve the items already fetched from that scope and record the
-			// failure in collection metadata rather than re-throwing and discarding the prefix. Callers without a
-			// scope keep the legacy throw behavior.
-			if (scope == null) throw ex;
-			return build({
-				truncated: true,
-				metadata: mergeCollectionMetadata(metadata, {
-					completeness: 'partial',
-					failures: [toCollectionScopeFailure(scope, ex)],
-				}),
-			});
-		}
-		if (result == null) {
-			if (page === 0) return build();
-
-			return build({
-				truncated: true,
-				...(scope != null
-					? {
-							metadata: mergeCollectionMetadata(metadata, {
-								completeness: 'partial',
-								failures: [
-									toCollectionScopeFailure(
-										scope,
-										new Error('Provider returned no page after advertising a continuation'),
-									),
-								],
-							}),
-						}
-					: undefined),
-			});
-		}
-
-		values.push(...result.values);
-		metadata = mergeCollectionMetadata(metadata, result.metadata);
-		truncated ||= result.paging?.truncated === true;
-
-		if (!result.paging?.more) return build();
-
-		if (result.paging.cursor === cursor) {
-			return build({ truncated: true });
-		}
-
-		cursor = result.paging.cursor;
-		if (cursor == null || cursor === '{}') {
-			return build({ truncated: true });
-		}
-		if (page === maxPages - 1) {
-			return build({ paging: result.paging, truncated: true });
-		}
-	}
-
-	return build();
-}