@gitkraken/core-gitlens 0.3.1 → 0.4.0

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

@@ -0,0 +1,359 @@
+import type { Account } from '../../../git/models/author.js';
+import type { AutolinkReference, DynamicAutolinkReference } from '../../../git/models/autolink.js';
+import type { Issue, IssueShape } from '../../../git/models/issue.js';
+import type { IssueOrPullRequest } from '../../../git/models/issueOrPullRequest.js';
+import type { IssueResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
+import { filterMap, flatten } from '../../../utils/iterable.js';
+import { Logger } from '../../../utils/logger.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 { IssuesIntegration } from '../models/issuesIntegration.js';
+import { IssueFilter, providersMetadata, toAccount, toIssueShape } from './models.js';
+
+const metadata = providersMetadata[IssuesCloudHostIntegrationId.Jira];
+const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
+const maxPagesPerRequest = 10;
+
+export type JiraBaseDescriptor = IssueResourceDescriptor;
+
+export interface JiraOrganizationDescriptor extends JiraBaseDescriptor {
+	url: string;
+	avatarUrl: string;
+}
+
+export interface JiraProjectDescriptor extends JiraBaseDescriptor {
+	resourceId: string;
+}
+
+export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegrationId.Jira> {
+	readonly authProvider: IntegrationAuthenticationProviderDescriptor = authProvider;
+	readonly id = IssuesCloudHostIntegrationId.Jira;
+	protected readonly key = this.id;
+	readonly name: string = 'Jira';
+
+	get domain(): string {
+		return metadata.domain;
+	}
+
+	protected get apiBaseUrl(): string {
+		return 'https://api.atlassian.com';
+	}
+
+	private _autolinks: Map<string, (AutolinkReference | DynamicAutolinkReference)[]> | undefined;
+	override async autolinks(): Promise<(AutolinkReference | DynamicAutolinkReference)[]> {
+		const connected = this.maybeConnected ?? (await this.isConnected());
+		if (!connected || this._session == null || this._organizations == null || this._projects == null) {
+			return [];
+		}
+
+		const cachedAutolinks = this._autolinks?.get(this._session.accessToken);
+		if (cachedAutolinks != null) return cachedAutolinks;
+
+		const autolinks: (AutolinkReference | DynamicAutolinkReference)[] = [];
+		const organizations = this._organizations.get(this._session.accessToken);
+		if (organizations != null) {
+			for (const organization of organizations) {
+				const projects = this._projects.get(`${this._session.accessToken}:${organization.id}`);
+				if (projects != null) {
+					for (const project of projects) {
+						const dashedPrefix = `${project.key}-`;
+						const underscoredPrefix = `${project.key}_`;
+						autolinks.push({
+							prefix: dashedPrefix,
+							url: `${organization.url}/browse/${dashedPrefix}<num>`,
+							alphanumeric: false,
+							ignoreCase: false,
+							title: `Open Issue ${dashedPrefix}<num> on ${organization.name}`,
+
+							type: 'issue',
+							description: `${organization.name} Issue ${dashedPrefix}<num>`,
+							descriptor: { ...organization },
+						});
+						autolinks.push({
+							prefix: underscoredPrefix,
+							url: `${organization.url}/browse/${dashedPrefix}<num>`,
+							alphanumeric: false,
+							ignoreCase: false,
+							referenceType: 'branch',
+							title: `Open Issue ${dashedPrefix}<num> on ${organization.name}`,
+
+							type: 'issue',
+							description: `${organization.name} Issue ${dashedPrefix}<num>`,
+							descriptor: { ...organization },
+						});
+					}
+				}
+			}
+		}
+
+		this._autolinks ??= new Map<string, (AutolinkReference | DynamicAutolinkReference)[]>();
+		this._autolinks.set(this._session.accessToken, autolinks);
+
+		return autolinks;
+	}
+
+	protected override async getProviderAccountForResource(
+		session: ProviderAuthenticationSession,
+		resource: JiraOrganizationDescriptor,
+	): Promise<Account | undefined> {
+		const api = await this.getProvidersApi();
+		const user = await api.getCurrentUserForResource(toTokenWithInfo(this.id, session), resource.id);
+
+		if (user == null) return undefined;
+		return toAccount(user, this);
+	}
+
+	private _organizations: Map<string, JiraOrganizationDescriptor[] | undefined> | undefined;
+	protected override async getProviderResourcesForUser(
+		session: ProviderAuthenticationSession,
+		force: boolean = false,
+	): Promise<JiraOrganizationDescriptor[] | undefined> {
+		const { accessToken } = session;
+		this._organizations ??= new Map<string, JiraOrganizationDescriptor[] | undefined>();
+
+		const cachedResources = this._organizations.get(accessToken);
+
+		if (cachedResources == null || force) {
+			const api = await this.getProvidersApi();
+			const resources = await api.getJiraResourcesForCurrentUser(toTokenWithInfo(this.id, session));
+			this._organizations.set(
+				accessToken,
+				resources != null ? resources.map(r => ({ ...r, key: r.id })) : undefined,
+			);
+		}
+
+		return this._organizations.get(accessToken);
+	}
+
+	private _projects: Map<string, JiraProjectDescriptor[] | undefined> | undefined;
+	protected override async getProviderProjectsForResources(
+		session: ProviderAuthenticationSession,
+		resources: JiraOrganizationDescriptor[],
+		force: boolean = false,
+	): Promise<JiraProjectDescriptor[] | undefined> {
+		const { accessToken } = session;
+		this._projects ??= new Map<string, JiraProjectDescriptor[] | undefined>();
+
+		let resourcesWithoutProjects = [];
+		if (force) {
+			resourcesWithoutProjects = resources;
+		} else {
+			for (const resource of resources) {
+				const resourceKey = `${accessToken}:${resource.id}`;
+				const cachedProjects = this._projects.get(resourceKey);
+				if (cachedProjects == null) {
+					resourcesWithoutProjects.push(resource);
+				}
+			}
+		}
+
+		if (resourcesWithoutProjects.length > 0) {
+			const api = await this.getProvidersApi();
+			const jiraProjectBaseDescriptors = await api.getJiraProjectsForResources(
+				toTokenWithInfo(this.id, session),
+				resourcesWithoutProjects.map(r => r.id),
+			);
+
+			for (const resource of resourcesWithoutProjects) {
+				const projects = jiraProjectBaseDescriptors?.filter(p => p.resourceId === resource.id);
+				if (projects != null) {
+					this._projects.set(
+						`${accessToken}:${resource.id}`,
+						projects.map(p => ({ ...p })),
+					);
+				}
+			}
+		}
+
+		return resources.reduce<JiraProjectDescriptor[]>((projects, resource) => {
+			const resourceProjects = this._projects!.get(`${accessToken}:${resource.id}`);
+			if (resourceProjects != null) {
+				projects.push(...resourceProjects);
+			}
+			return projects;
+		}, []);
+	}
+
+	protected override async getProviderIssuesForProject(
+		session: ProviderAuthenticationSession,
+		project: JiraProjectDescriptor,
+		options?: { user: string; filters: IssueFilter[] },
+	): Promise<IssueShape[] | undefined> {
+		let results;
+		const tokenWithInfo = toTokenWithInfo(this.id, session);
+
+		const api = await this.getProvidersApi();
+
+		const getSearchedUserIssuesForFilter = async (
+			user: string,
+			filter: IssueFilter,
+		): Promise<IssueShape[] | undefined> => {
+			const results = await api.getIssuesForProject(tokenWithInfo, project.name, project.resourceId, {
+				authorLogin: filter === IssueFilter.Author ? user : undefined,
+				assigneeLogins: filter === IssueFilter.Assignee ? [user] : undefined,
+				mentionLogin: filter === IssueFilter.Mention ? user : undefined,
+			});
+
+			return results
+				?.map(issue => toIssueShape(issue, this))
+				.filter((result): result is IssueShape => result !== undefined);
+		};
+
+		if (options?.user != null && options.filters.length > 0) {
+			const resultsPromise = Promise.allSettled(
+				options.filters.map(filter => getSearchedUserIssuesForFilter(options.user, filter)),
+			);
+
+			results = [
+				...flatten(
+					filterMap(await resultsPromise, r =>
+						r.status === 'fulfilled' && r.value != null ? r.value : undefined,
+					),
+				),
+			];
+
+			const resultsById = new Map<string, IssueShape>();
+			for (const resultIssue of results) {
+				if (!resultsById.has(resultIssue.id)) {
+					resultsById.set(resultIssue.id, resultIssue);
+				}
+			}
+
+			return [...resultsById.values()];
+		}
+
+		results = await api.getIssuesForProject(tokenWithInfo, project.name, project.resourceId);
+		return results
+			?.map(issue => toIssueShape(issue, this))
+			.filter((result): result is IssueShape => result !== undefined);
+	}
+
+	protected override async searchProviderMyIssues(
+		session: ProviderAuthenticationSession,
+		resources?: JiraOrganizationDescriptor[],
+		cancellation?: AbortSignal,
+	): Promise<IssueShape[] | undefined> {
+		const myResources = resources ?? (await this.getProviderResourcesForUser(session));
+		if (!myResources) return undefined;
+
+		const api = await this.getProvidersApi();
+
+		const results: IssueShape[] = [];
+		for (const resource of myResources) {
+			if (cancellation?.aborted) break;
+
+			try {
+				let cursor = undefined;
+				let hasMore = false;
+				let requestCount = 0;
+				do {
+					if (cancellation?.aborted) break;
+
+					const resourceIssues = await api.getIssuesForResourceForCurrentUser(
+						toTokenWithInfo(this.id, session),
+						resource.id,
+						{
+							cursor: cursor,
+						},
+					);
+					requestCount += 1;
+					hasMore = resourceIssues.paging?.more ?? false;
+					cursor = resourceIssues.paging?.cursor;
+					const formattedIssues = resourceIssues.values
+						.map(issue => toIssueShape(issue, this))
+						.filter((result): result is IssueShape => result != null);
+					if (formattedIssues.length > 0) {
+						results.push(...formattedIssues);
+					}
+				} while (requestCount < maxPagesPerRequest && hasMore);
+			} catch (ex) {
+				// TODO: We need a better way to message the failure to the user here.
+				// This is a stopgap to prevent one bag org from throwing and preventing any issues from being returned.
+				Logger.error(ex, 'searchProviderMyIssues');
+			}
+		}
+
+		return results;
+	}
+
+	protected override async getProviderLinkedIssueOrPullRequest(
+		session: ProviderAuthenticationSession,
+		resource: JiraOrganizationDescriptor,
+		{ key }: { id: string; key: string },
+	): Promise<IssueOrPullRequest | undefined> {
+		const api = await this.getProvidersApi();
+		const issue = await api.getIssue(toTokenWithInfo(this.id, session), {
+			resourceId: resource.id,
+			number: key,
+		});
+		return issue != null ? toIssueShape(issue, this) : undefined;
+	}
+
+	protected override async getProviderIssue(
+		session: ProviderAuthenticationSession,
+		resource: JiraOrganizationDescriptor,
+		id: string,
+	): Promise<Issue | undefined> {
+		const api = await this.getProvidersApi();
+		const apiResult = await api.getIssue(toTokenWithInfo(this.id, session), {
+			resourceId: resource.id,
+			number: id,
+		});
+		const issue = apiResult != null ? toIssueShape(apiResult, this) : undefined;
+		return issue != null ? { ...issue, type: 'issue' } : undefined;
+	}
+
+	protected override async providerOnConnect(): Promise<void> {
+		this._autolinks = undefined;
+		if (this._session == null) return;
+
+		const storedOrganizations = this.ctx.storage.get(`jira:${this._session.accessToken}:organizations`);
+		const storedProjects = this.ctx.storage.get(`jira:${this._session.accessToken}:projects`);
+
+		let organizations = storedOrganizations?.data?.map((o: JiraOrganizationDescriptor) => ({ ...o }));
+
+		let projects = storedProjects?.data?.map((p: JiraProjectDescriptor) => ({ ...p }));
+
+		if (storedOrganizations == null) {
+			organizations = await this.getProviderResourcesForUser(this._session, true);
+			// Clear all other stored organizations and projects when our session changes
+			await this.ctx.storage.deleteWithPrefix('jira');
+			await this.ctx.storage.store(`jira:${this._session.accessToken}:organizations`, {
+				v: 1,
+				timestamp: Date.now(),
+				data: organizations,
+			});
+		}
+
+		this._organizations ??= new Map<string, JiraOrganizationDescriptor[] | undefined>();
+		this._organizations.set(this._session.accessToken, organizations);
+
+		if (storedProjects == null && organizations?.length) {
+			projects = await this.getProviderProjectsForResources(this._session, organizations);
+			await this.ctx.storage.store(`jira:${this._session.accessToken}:projects`, {
+				v: 1,
+				timestamp: Date.now(),
+				data: projects,
+			});
+		}
+
+		this._projects ??= new Map<string, JiraProjectDescriptor[] | undefined>();
+		for (const project of projects ?? []) {
+			const projectKey = `${this._session.accessToken}:${project.resourceId}`;
+			const projects = this._projects.get(projectKey);
+			if (projects == null) {
+				this._projects.set(projectKey, [project]);
+			} else if (!projects.some(p => p.id === project.id)) {
+				projects.push(project);
+			}
+		}
+	}
+
+	protected override providerOnDisconnect(): void {
+		this._organizations = undefined;
+		this._projects = undefined;
+		this._autolinks = undefined;
+	}
+}

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

@@ -0,0 +1,275 @@
+import type { Account } from '../../../git/models/author.js';
+import type { AutolinkReference, DynamicAutolinkReference } from '../../../git/models/autolink.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 { Logger } from '../../../utils/logger.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 { IssuesIntegration } from '../models/issuesIntegration.js';
+import type { IssueFilter, ProviderIssue } from './models.js';
+import { fromProviderIssue, providersMetadata, toIssueShape } from './models.js';
+
+const metadata = providersMetadata[IssuesCloudHostIntegrationId.Linear];
+const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
+const maxPagesPerRequest = 10;
+
+export interface LinearTeamDescriptor extends IssueResourceDescriptor {
+	avatarUrl: string | undefined;
+}
+
+export interface LinearOrganizationDescriptor extends IssueResourceDescriptor {
+	url: string;
+}
+
+export interface LinearProjectDescriptor extends IssueResourceDescriptor {}
+
+export class LinearIntegration extends IssuesIntegration<IssuesCloudHostIntegrationId.Linear> {
+	private _autolinks: Map<string, (AutolinkReference | DynamicAutolinkReference)[]> | undefined;
+	override async autolinks(): Promise<(AutolinkReference | DynamicAutolinkReference)[]> {
+		const connected = this.maybeConnected ?? (await this.isConnected());
+		if (!connected || this._session == null) {
+			return [];
+		}
+
+		const cachedAutolinks = this._autolinks?.get(this._session.accessToken);
+		if (cachedAutolinks != null) return cachedAutolinks;
+
+		const organization = await this.getOrganization(this._session);
+		if (organization == null) return [];
+
+		const autolinks: (AutolinkReference | DynamicAutolinkReference)[] = [];
+
+		const teams = await this.getTeams(this._session);
+		for (const team of teams ?? []) {
+			const dashedPrefix = `${team.key}-`;
+			const underscoredPrefix = `${team.key}_`;
+
+			autolinks.push({
+				prefix: dashedPrefix,
+				url: `${organization.url}/issue/${dashedPrefix}<num>`,
+				alphanumeric: false,
+				ignoreCase: false,
+				title: `Open Issue ${dashedPrefix}<num> on ${organization.name}`,
+
+				type: 'issue',
+				description: `${organization.name} Issue ${dashedPrefix}<num>`,
+				descriptor: { ...organization },
+			});
+			autolinks.push({
+				prefix: underscoredPrefix,
+				url: `${organization.url}/issue/${dashedPrefix}<num>`,
+				alphanumeric: false,
+				ignoreCase: false,
+				referenceType: 'branch',
+				title: `Open Issue ${dashedPrefix}<num> on ${organization.name}`,
+
+				type: 'issue',
+				description: `${organization.name} Issue ${dashedPrefix}<num>`,
+				descriptor: { ...organization },
+			});
+		}
+
+		this._autolinks ??= new Map<string, (AutolinkReference | DynamicAutolinkReference)[]>();
+		this._autolinks.set(this._session.accessToken, autolinks);
+
+		return autolinks;
+	}
+
+	private _organizations: Map<string, LinearOrganizationDescriptor | undefined> | undefined;
+	private async getOrganization(
+		session: ProviderAuthenticationSession,
+		force: boolean = false,
+	): Promise<LinearOrganizationDescriptor | undefined> {
+		const { accessToken } = session;
+		this._organizations ??= new Map<string, LinearOrganizationDescriptor | undefined>();
+
+		const cachedResources = this._organizations.get(accessToken);
+
+		if (cachedResources == null || force) {
+			const api = await this.getProvidersApi();
+			const organization = await api.getLinearOrganization(toTokenWithInfo(this.id, session));
+			const descriptor: LinearOrganizationDescriptor | undefined = organization && {
+				id: organization.id,
+				key: organization.key,
+				name: organization.name,
+				url: organization.url,
+			};
+			if (descriptor) {
+				this._organizations.set(accessToken, descriptor);
+			}
+		}
+
+		return this._organizations.get(accessToken);
+	}
+
+	private _teams: Map<string, LinearTeamDescriptor[] | undefined> | undefined;
+	private async getTeams(
+		session: ProviderAuthenticationSession,
+		force: boolean = false,
+	): Promise<LinearTeamDescriptor[] | undefined> {
+		const { accessToken } = session;
+		this._teams ??= new Map<string, LinearTeamDescriptor[] | undefined>();
+
+		const cachedResources = this._teams.get(accessToken);
+
+		if (cachedResources == null || force) {
+			const api = await this.getProvidersApi();
+			const teams = await api.getLinearTeamsForCurrentUser(toTokenWithInfo(this.id, session));
+			const descriptors: LinearTeamDescriptor[] | undefined = teams?.map(t => ({
+				id: t.id,
+				key: t.key,
+				name: t.name,
+				avatarUrl: t.iconUrl,
+			}));
+			if (descriptors) {
+				this._teams.set(accessToken, descriptors);
+			}
+		}
+
+		return this._teams.get(accessToken);
+	}
+
+	protected override getProviderResourcesForUser(
+		_session: ProviderAuthenticationSession,
+	): Promise<ResourceDescriptor[] | undefined> {
+		throw new Error('Method not implemented.');
+	}
+	protected override getProviderProjectsForResources(
+		_session: ProviderAuthenticationSession,
+		_resources: ResourceDescriptor[],
+	): Promise<ResourceDescriptor[] | undefined> {
+		throw new Error('Method not implemented.');
+	}
+	readonly authProvider: IntegrationAuthenticationProviderDescriptor = authProvider;
+
+	protected override getProviderAccountForResource(
+		_session: ProviderAuthenticationSession,
+		_resource: ResourceDescriptor,
+	): Promise<Account | undefined> {
+		throw new Error('Method not implemented.');
+	}
+
+	protected override getProviderIssuesForProject(
+		_session: ProviderAuthenticationSession,
+		_project: ResourceDescriptor,
+		_options?: { user?: string; filters?: IssueFilter[] },
+	): Promise<IssueShape[] | undefined> {
+		throw new Error('Method not implemented.');
+	}
+
+	override get id(): IssuesCloudHostIntegrationId.Linear {
+		return IssuesCloudHostIntegrationId.Linear;
+	}
+	protected override get key(): 'linear' {
+		return 'linear';
+	}
+	override get name(): string {
+		return metadata.name;
+	}
+	override get domain(): string {
+		return metadata.domain;
+	}
+	protected override async searchProviderMyIssues(
+		session: ProviderAuthenticationSession,
+		resources?: ResourceDescriptor[],
+		cancellation?: AbortSignal,
+	): Promise<IssueShape[] | undefined> {
+		if (resources != null) {
+			return undefined;
+		}
+
+		const api = await this.getProvidersApi();
+		let cursor = undefined;
+		let hasMore: boolean;
+		let requestCount = 0;
+		const issues = [];
+		try {
+			do {
+				if (cancellation?.aborted) {
+					break;
+				}
+
+				const result = await api.getIssuesForCurrentUser(toTokenWithInfo(this.id, session), {
+					cursor: cursor,
+				});
+				requestCount += 1;
+				hasMore = result.paging?.more ?? false;
+				cursor = result.paging?.cursor;
+				const formattedIssues = result.values
+					.map(issue => toIssueShape(issue, this))
+					.filter((result): result is IssueShape => result != null);
+				if (formattedIssues.length > 0) {
+					issues.push(...formattedIssues);
+				}
+			} while (requestCount < maxPagesPerRequest && hasMore);
+		} catch (ex) {
+			if (issues.length === 0) {
+				throw ex;
+			}
+
+			Logger.error(ex, 'searchProviderMyIssues');
+		}
+		return issues;
+	}
+	protected override async getProviderLinkedIssueOrPullRequest(
+		session: ProviderAuthenticationSession,
+		resource: ResourceDescriptor,
+		{ key }: { id: string; key: string },
+		_type: undefined | IssueOrPullRequestType,
+	): Promise<IssueOrPullRequest | undefined> {
+		const issue = await this.getRawProviderIssue(session, resource, key);
+		const autolinkableIssue: ProviderIssue | undefined = issue && {
+			...issue,
+			url: this.getIssueAutolinkLikeUrl(issue),
+		};
+		return autolinkableIssue && toIssueShape(autolinkableIssue, this);
+	}
+	protected override async getProviderIssue(
+		session: ProviderAuthenticationSession,
+		resource: ResourceDescriptor,
+		id: string,
+	): Promise<Issue | undefined> {
+		const result = await this.getRawProviderIssue(session, resource, id);
+		return result && fromProviderIssue(result, this);
+	}
+
+	private async getRawProviderIssue(
+		session: ProviderAuthenticationSession,
+		resource: ResourceDescriptor,
+		id: string,
+	): Promise<ProviderIssue | undefined> {
+		const api = await this.getProvidersApi();
+		try {
+			if (!isIssueResourceDescriptor(resource)) {
+				Logger.error(undefined, 'getProviderIssue: resource is not an IssueResourceDescriptor');
+				return undefined;
+			}
+
+			const result = await api.getIssue(toTokenWithInfo(this.id, session), {
+				resourceId: resource.id,
+				number: id,
+			});
+
+			if (result == null) return undefined;
+
+			return result;
+		} catch (ex) {
+			Logger.error(ex, 'getProviderIssue');
+			return undefined;
+		}
+	}
+	private getIssueAutolinkLikeUrl(issue: ProviderIssue): string | null {
+		const url = issue.url;
+		if (url == null) return null;
+
+		const lastSegment = url.split('/').pop();
+		if (!lastSegment || issue.number === lastSegment) {
+			return url;
+		}
+		return url.substring(0, url.length - lastSegment.length - 1);
+	}
+}