@gitkraken/core-gitlens 0.3.0 → 0.4.0

package/src/plus/integrations/models/issuesIntegration.ts

@@ -0,0 +1,124 @@
+import type { Account } from '../../../git/models/author.js';
+import type { IssueShape } from '../../../git/models/issue.js';
+import type { ResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
+import { gate } from '../../../utils/decorators/gate.js';
+import { trace } from '../../../utils/decorators/log.js';
+import { getScopedLogger } from '../../../utils/logger.scoped.js';
+import type { ProviderAuthenticationSession } from '../authentication/models.js';
+import type { IntegrationIds } from '../constants.js';
+import type { IssueFilter } from '../providers/models.js';
+import type { Integration, IntegrationType } from './integration.js';
+import { IntegrationBase } from './integration.js';
+
+export function isIssuesIntegration(integration: Integration): integration is IssuesIntegration {
+	return integration.type === 'issues';
+}
+
+export abstract class IssuesIntegration<
+	ID extends IntegrationIds = IntegrationIds,
+	T extends ResourceDescriptor = ResourceDescriptor,
+> extends IntegrationBase<ID> {
+	readonly type: IntegrationType = 'issues';
+
+	@gate()
+	@trace()
+	async getAccountForResource(resource: T): Promise<Account | undefined> {
+		const scope = getScopedLogger();
+		const connected = this.maybeConnected ?? (await this.isConnected());
+		if (!connected) return undefined;
+
+		await this.refreshSessionIfExpired(scope);
+
+		try {
+			const account = await this.getProviderAccountForResource(this._session!, resource);
+			this.resetRequestExceptionCount('getAccountForResource');
+			return account;
+		} catch (ex) {
+			this.handleProviderException('getAccountForResource', ex);
+			return undefined;
+		}
+	}
+
+	protected abstract getProviderAccountForResource(
+		session: ProviderAuthenticationSession,
+		resource: T,
+	): Promise<Account | undefined>;
+
+	@gate()
+	@trace()
+	async getResourcesForUser(): Promise<T[] | undefined> {
+		const scope = getScopedLogger();
+		const connected = this.maybeConnected ?? (await this.isConnected());
+		if (!connected) return undefined;
+
+		await this.refreshSessionIfExpired(scope);
+
+		try {
+			const resources = await this.getProviderResourcesForUser(this._session!);
+			this.resetRequestExceptionCount('getResourcesForUser');
+			return resources;
+		} catch (ex) {
+			this.handleProviderException('getResourcesForUser', ex);
+			return undefined;
+		}
+	}
+
+	protected abstract getProviderResourcesForUser(session: ProviderAuthenticationSession): Promise<T[] | undefined>;
+
+	@trace()
+	async getProjectsForResources(resources: T[]): Promise<T[] | undefined> {
+		const scope = getScopedLogger();
+		const connected = this.maybeConnected ?? (await this.isConnected());
+		if (!connected) return undefined;
+
+		await this.refreshSessionIfExpired(scope);
+
+		try {
+			const projects = await this.getProviderProjectsForResources(this._session!, resources);
+			this.resetRequestExceptionCount('getProjectsForResources');
+			return projects;
+		} catch (ex) {
+			this.handleProviderException('getProjectsForResources', ex);
+			return undefined;
+		}
+	}
+
+	async getProjectsForUser(): Promise<T[] | undefined> {
+		const resources = await this.getResourcesForUser();
+		if (resources == null) return undefined;
+
+		return this.getProjectsForResources(resources);
+	}
+
+	protected abstract getProviderProjectsForResources(
+		session: ProviderAuthenticationSession,
+		resources: T[],
+	): Promise<T[] | undefined>;
+
+	@trace()
+	async getIssuesForProject(
+		project: T,
+		options?: { user?: string; filters?: IssueFilter[] },
+	): Promise<IssueShape[] | undefined> {
+		const scope = getScopedLogger();
+		const connected = this.maybeConnected ?? (await this.isConnected());
+		if (!connected) return undefined;
+
+		await this.refreshSessionIfExpired(scope);
+
+		try {
+			const issues = await this.getProviderIssuesForProject(this._session!, project, options);
+			this.resetRequestExceptionCount('getIssuesForProject');
+			return issues;
+		} catch (ex) {
+			this.handleProviderException('getIssuesForProject', ex);
+			return undefined;
+		}
+	}
+
+	protected abstract getProviderIssuesForProject(
+		session: ProviderAuthenticationSession,
+		project: T,
+		options?: { user?: string; filters?: IssueFilter[] },
+	): Promise<IssueShape[] | undefined>;
+}

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

@@ -0,0 +1,72 @@
+import type { Disposable } from '../../../utils/disposable.js';
+import { getScopedLogger } from '../../../utils/logger.scoped.js';
+import type { IntegrationServiceContext } from '../context.js';
+import type { AzureDevOpsApi } from './azure/azure.js';
+import type { BitbucketApi } from './bitbucket/bitbucket.js';
+import type { GitHubApi } from './github/github.js';
+import type { GitLabApi } from './gitlab/gitlab.js';
+
+/**
+ * The per-provider API clients, owned and built by the package. `GitLabApi`/`BitbucketApi`/`AzureDevOpsApi`
+ * live in the package; `GitHubApi` comes from `@gitkraken/core-gitlens/plus/git-github` (shared with the host's GitHub git
+ * provider, which reads the manager's memoized instance via `manager.github`). `undefined` is tolerated for
+ * offline/limited runtimes.
+ */
+export interface ApiClients {
+	readonly github: Promise<GitHubApi | undefined>;
+	readonly gitlab: Promise<GitLabApi | undefined>;
+	readonly bitbucket: Promise<BitbucketApi | undefined>;
+	readonly azure: Promise<AzureDevOpsApi | undefined>;
+}
+
+/**
+ * Lazily constructs + memoizes the API clients from the runtime context, pushing each to `disposables` for
+ * teardown. Mirrors the lazy-chunked construction the host's `Container` did before the package took
+ * ownership (the host used to build these and inject them back through the context — a pure round-trip).
+ */
+export function createApiClients(ctx: IntegrationServiceContext, disposables: Disposable[]): ApiClients {
+	let github: Promise<GitHubApi | undefined> | undefined;
+	let gitlab: Promise<GitLabApi | undefined> | undefined;
+	let bitbucket: Promise<BitbucketApi | undefined> | undefined;
+	let azure: Promise<AzureDevOpsApi | undefined> | undefined;
+
+	const build = async <T extends Disposable>(load: () => Promise<T>): Promise<T | undefined> => {
+		const scope = getScopedLogger();
+		try {
+			const api = await load();
+			disposables.push(api);
+			return api;
+		} catch (ex) {
+			scope?.error(ex, 'Failed to construct integration API client');
+			return undefined;
+		}
+	};
+
+	return {
+		get github() {
+			return (github ??= build(async () =>
+				(await import(/* webpackChunkName: "integrations" */ './github/github.js')).createGitHubApi(ctx),
+			));
+		},
+		get gitlab() {
+			return (gitlab ??= build(
+				async () =>
+					new (await import(/* webpackChunkName: "integrations" */ './gitlab/gitlab.js')).GitLabApi(ctx),
+			));
+		},
+		get bitbucket() {
+			return (bitbucket ??= build(
+				async () =>
+					new (await import(/* webpackChunkName: "integrations" */ './bitbucket/bitbucket.js')).BitbucketApi(
+						ctx,
+					),
+			));
+		},
+		get azure() {
+			return (azure ??= build(
+				async () =>
+					new (await import(/* webpackChunkName: "integrations" */ './azure/azure.js')).AzureDevOpsApi(ctx),
+			));
+		},
+	};
+}