@gitkraken/core-gitlens 0.10.1 → 0.10.3

package/dist/plus/integrations/models/integration.d.ts

@@ -165,12 +165,20 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
   get connectionExpired(): boolean | undefined;
   protected _session: ProviderAuthenticationSession | null | undefined;
   /**
-   * Bumped whenever a forced re-sync's refetch settles `_session`. A forced re-sync keeps the stored token while it
-   * fetches the replacement, so a read that resolved that token concurrently must not publish it over whatever the
-   * refetch settled on: a fresh token, or nothing after the cloud said the connection is gone.
+   * Every change to the session (a resolution, a forced re-sync, a disconnect, a reauthentication, a connection
+   * switch, a refused token) runs here, one at a time. Each one reads storage and the cloud and then settles
+   * `_session`, the stored tokens and the connected flag; run concurrently, one would publish what it read over
+   * what another settled meanwhile (gitkraken/kepler#3546). Reads don't queue: they read `_session` as it is.
    */
-  private _sessionGeneration;
+  private _sessionTransitions;
+  /**
+   * Runs `fn` after every transition queued before it. `fn` must not queue another transition and wait for it,
+   * which would wait for itself: inside a transition, call the `*Locked` methods instead.
+   */
+  protected runSessionTransition<T>(fn: () => Promise<T>): Promise<T>;
+  /** An expired session is refreshed first; when that fails, nothing is returned rather than a token the provider refuses. */
   getSession(source: Sources): ProviderAuthenticationSession | Promise<ProviderAuthenticationSession | undefined> | undefined;
+  private getRefreshedSession;
   private isSessionForIntegrationHost;
   /**
    * Resolves the session to read as, for a per-connection (multi-account) read. When `connectionId` is
@@ -188,6 +196,11 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
    * limit as `rate-limit`, anything else as `other`.
    */
   protected resolveReadSession(connectionId: string | undefined, scope: ScopedLogger | undefined, source?: Sources): Promise<ProviderAuthenticationSession | ReadSessionFailure | undefined>;
+  /**
+   * The session lookups' prelude for a caller that can surface a failure (`throwOnError`): the refresh's failure to
+   * report, or `'unconnected'`, so a throttled refresh is not mistaken for "no pull request" and kept.
+   */
+  protected prepareSessionLookup(): Promise<Error | 'unconnected' | undefined>;
   /**
    * {@link resolveReadSession} for a read that already rethrows its provider's failures (a repository or account
    * lookup), or whose callers treat any failure as "nothing to show": a token that could not be fetched is
@@ -201,9 +214,15 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
     silent?: boolean;
     currentSessionOnly?: boolean;
   }): Promise<void>;
+  private disconnectLocked;
   protected providerOnDisconnect?(): void | Promise<void>;
   reauthenticate(): Promise<void>;
   refresh(): void;
+  /**
+   * Drops the cached session when its token is no longer `accessToken` (a session replaced outside the
+   * integration) and resolves it again, in one transition, so nothing in flight publishes the replaced one.
+   */
+  protected resyncSessionIfTokenChanged(accessToken: string | undefined): Promise<void>;
   private _syncRequestsPerFailedUsecase;
   hasSessionSyncRequests(): boolean;
   requestSessionSyncForUsecase(syncReqUsecase: SyncReqUsecase): void;
@@ -247,10 +266,14 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
    * connection changed underneath a warm integration (e.g. after `setPrimaryConnection`/
    * `deleteConnection`). Unlike {@link reset}/{@link disconnect}, it deletes nothing from storage.
    */
-  switchConnection(): void;
-  private refreshAfterSwitch;
+  switchConnection(): Promise<void>;
   private skippedNonCloudReported;
-  syncCloudConnection(state: 'connected' | 'disconnected', forceSync: boolean): Promise<void>;
+  /**
+   * Resolves the re-sync's failure, when its token fetch threw (cancellations included), so a caller can report it.
+   * Never rejects: the cloud sync fans this out over every integration and must not fail on one.
+   */
+  syncCloudConnection(state: 'connected' | 'disconnected', forceSync: boolean): Promise<Error | undefined>;
+  private syncCloudConnectionLocked;
   /**
    * Proves the credential with an uncached check, rejecting with the provider's `AuthenticationError` when it is
    * refused, and with anything else when the check proves nothing. A `403` proves nothing either: the credential
@@ -360,13 +383,28 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
     silent?: boolean;
     connectionId?: string;
   }): boolean;
+  private expireSessionIfToken;
+  /** Counts completed cloud re-syncs, so a refresh queued behind one reuses its outcome rather than running another. */
+  private _resyncs;
+  private _lastResyncFailure;
   private missingExpirityReported;
-  protected refreshSessionIfExpired(scope?: ScopedLogger): Promise<void>;
+  /**
+   * Resolves the refresh's failure while the session it could not replace is still unusable, so a read can report
+   * that instead of reading with an expired token or as a missing connection.
+   */
+  protected refreshSessionIfExpired(): Promise<Error | undefined>;
   trackRequestException(options?: {
     silent?: boolean;
   }): void;
   isConnected(): Promise<boolean>;
   private ensureSession;
+  /**
+   * Asks the auth provider for a session interactively, storing what it gets; whether one came back. A declined
+   * consent or any other failure is not one, and never throws: it is resolved, like any read, from storage.
+   */
+  private signIn;
+  /** Resolves and publishes the session. Only ever runs inside a transition (see {@link runSessionTransition}). */
+  private resolveSessionLocked;
   getIgnoreSSLErrors(): boolean | 'force';
   searchMyIssues(resource?: ResourceDescriptor, cancellation?: AbortSignal, connectionId?: string): Promise<IssueShape[] | undefined>;
   searchMyIssues(resources?: ResourceDescriptor[], cancellation?: AbortSignal, connectionId?: string): Promise<IssueShape[] | undefined>;

package/dist/plus/integrations/models/integration.js

@@ -8,7 +8,7 @@ import { AuthenticationError, RequestClientError, getDeferredRequestFailure } fr
 import { Emitter } from "../../../utils/event.js";
 import { fnv1aHash64 } from "../../../utils/hash.js";
 import { gate } from "../../../utils/decorators/gate.js";
-import { toError } from "../errors.js";
+import { isProviderUnreachableError, toError } from "../errors.js";
 import "../constants.js";
 import { isAzureProviderId } from "../providers/providerErrors.js";
 import { attributeScopedAuthFailures, hasOnlyScopedAuthFailures, markCredentialRefusals, toCollectionScopeFailure } from "../collectionMetadata.js";
@@ -144,17 +144,34 @@ var IntegrationBase = class IntegrationBase {
 	}
 	_session;
 	/**
-	* Bumped whenever a forced re-sync's refetch settles `_session`. A forced re-sync keeps the stored token while it
-	* fetches the replacement, so a read that resolved that token concurrently must not publish it over whatever the
-	* refetch settled on: a fresh token, or nothing after the cloud said the connection is gone.
+	* Every change to the session (a resolution, a forced re-sync, a disconnect, a reauthentication, a connection
+	* switch, a refused token) runs here, one at a time. Each one reads storage and the cloud and then settles
+	* `_session`, the stored tokens and the connected flag; run concurrently, one would publish what it read over
+	* what another settled meanwhile (gitkraken/kepler#3546). Reads don't queue: they read `_session` as it is.
 	*/
-	_sessionGeneration = 0;
+	_sessionTransitions = Promise.resolve();
+	/**
+	* Runs `fn` after every transition queued before it. `fn` must not queue another transition and wait for it,
+	* which would wait for itself: inside a transition, call the `*Locked` methods instead.
+	*/
+	runSessionTransition(fn) {
+		const run = this._sessionTransitions.then(fn);
+		this._sessionTransitions = run.then(() => void 0, () => void 0);
+		return run;
+	}
+	/** An expired session is refreshed first; when that fails, nothing is returned rather than a token the provider refuses. */
 	getSession(source) {
 		if (this._session === void 0) return this.ensureSession({
 			createIfNeeded: false,
 			source
 		});
-		return this._session != null && this.isSessionForIntegrationHost(this._session) ? this._session : void 0;
+		if (this._session == null || !this.isSessionForIntegrationHost(this._session)) return void 0;
+		if (this.connectionExpired) return this.getRefreshedSession();
+		return this._session;
+	}
+	async getRefreshedSession() {
+		if (await this.refreshSessionIfExpired() != null) return void 0;
+		return this._session != null && this.connectionExpired !== true && this.isSessionForIntegrationHost(this._session) ? this._session : void 0;
 	}
 	isSessionForIntegrationHost(session) {
 		if (!isSelfManagedHostIntegrationId(this.id)) return true;
@@ -196,10 +213,21 @@ var IntegrationBase = class IntegrationBase {
 			}
 		}
 		if (!(this.maybeConnected ?? await this.isConnected())) return void 0;
-		await this.refreshSessionIfExpired(scope);
+		const refreshFailure = await this.refreshSessionIfExpired();
+		if (refreshFailure != null) return new ReadSessionFailure(refreshFailure);
 		return this._session != null && this.isSessionForIntegrationHost(this._session) ? this._session : void 0;
 	}
 	/**
+	* The session lookups' prelude for a caller that can surface a failure (`throwOnError`): the refresh's failure to
+	* report, or `'unconnected'`, so a throttled refresh is not mistaken for "no pull request" and kept.
+	*/
+	async prepareSessionLookup() {
+		if (!(this.maybeConnected ?? await this.isConnected())) return "unconnected";
+		const failure = await this.refreshSessionIfExpired();
+		if (failure != null) return failure;
+		return this._session != null ? void 0 : "unconnected";
+	}
+	/**
 	* {@link resolveReadSession} for a read that already rethrows its provider's failures (a repository or account
 	* lookup), or whose callers treat any failure as "nothing to show": a token that could not be fetched is
 	* thrown like those failures, so it is classified as the failed request it is rather than as a missing
@@ -222,9 +250,8 @@ var IntegrationBase = class IntegrationBase {
 	}
 	async disconnect(options) {
 		if (options?.currentSessionOnly && this._session === null) return;
-		const connected = this._session != null;
 		let signOut = !options?.currentSessionOnly;
-		if (connected && !options?.currentSessionOnly && !options?.silent) {
+		if (this._session != null && !options?.currentSessionOnly && !options?.silent) {
 			const decision = await this.ctx.hooks?.onConfirmDisconnect?.({
 				integrationName: this.name,
 				offerSignOut: this.authenticationService.supports(this.authProvider.id)
@@ -232,6 +259,11 @@ var IntegrationBase = class IntegrationBase {
 			if (decision == null) return;
 			signOut = decision.signOut;
 		}
+		await this.runSessionTransition(() => this.disconnectLocked(options, signOut));
+	}
+	async disconnectLocked(options, signOut) {
+		if (options?.currentSessionOnly && this._session === null) return;
+		const connected = this._session != null;
 		if (signOut) await (await this.authenticationService.get(this.authProvider.id)).deleteAllSessions(this.authProviderDescriptor);
 		this.resetRequestExceptionCount("all");
 		this._session = null;
@@ -248,8 +280,11 @@ var IntegrationBase = class IntegrationBase {
 	}
 	async reauthenticate() {
 		this.onStoredTokensReplaced();
-		if (this._session === void 0) return;
-		this._session = void 0;
+		if (!await this.runSessionTransition(() => {
+			if (this._session === void 0) return Promise.resolve(false);
+			this._session = void 0;
+			return Promise.resolve(true);
+		})) return;
 		await this.ensureSession({
 			createIfNeeded: true,
 			forceNewSession: true
@@ -258,6 +293,16 @@ var IntegrationBase = class IntegrationBase {
 	refresh() {
 		this.ensureSession({ createIfNeeded: false });
 	}
+	/**
+	* Drops the cached session when its token is no longer `accessToken` (a session replaced outside the
+	* integration) and resolves it again, in one transition, so nothing in flight publishes the replaced one.
+	*/
+	resyncSessionIfTokenChanged(accessToken) {
+		return this.runSessionTransition(async () => {
+			if (this._session != null && this._session.accessToken !== accessToken) this._session = void 0;
+			await this.resolveSessionLocked({ createIfNeeded: false });
+		});
+	}
 	_syncRequestsPerFailedUsecase = /* @__PURE__ */ new Set();
 	hasSessionSyncRequests() {
 		return this._syncRequestsPerFailedUsecase.size > 0;
@@ -311,8 +356,10 @@ var IntegrationBase = class IntegrationBase {
 		this.requestExceptionCount = 0;
 	}
 	async reset() {
-		await this.disconnect({ silent: true });
-		await this.ctx.storage.deleteWorkspace(this.connectedKey);
+		await this.runSessionTransition(async () => {
+			await this.disconnectLocked({ silent: true }, true);
+			await this.ctx.storage.deleteWorkspace(this.connectedKey);
+		});
 	}
 	/**
 	* Drops the in-memory session so the next access re-resolves it from storage. Used when the primary
@@ -321,24 +368,30 @@ var IntegrationBase = class IntegrationBase {
 	*/
 	switchConnection() {
 		this.onStoredTokensReplaced();
-		if (this._session === void 0) return;
-		const wasConnected = this._session != null;
-		this._session = void 0;
-		this._onDidChange.fire();
-		this.refreshAfterSwitch(wasConnected);
-	}
-	async refreshAfterSwitch(wasConnected) {
-		if (await this.ensureSession({ createIfNeeded: false }) != null || !wasConnected) return;
-		this._onDidChange.fire();
-		this.didChangeConnection?.fire({
-			integration: this,
-			key: this.key,
-			reason: "disconnected"
+		return this.runSessionTransition(async () => {
+			if (this._session === void 0) return;
+			const wasConnected = this._session != null;
+			this._session = void 0;
+			this._onDidChange.fire();
+			if (await this.resolveSessionLocked({ createIfNeeded: false }) != null || !wasConnected) return;
+			this._onDidChange.fire();
+			this.didChangeConnection?.fire({
+				integration: this,
+				key: this.key,
+				reason: "disconnected"
+			});
+			await this.providerOnDisconnect?.();
 		});
-		await this.providerOnDisconnect?.();
 	}
 	skippedNonCloudReported = false;
-	async syncCloudConnection(state, forceSync) {
+	/**
+	* Resolves the re-sync's failure, when its token fetch threw (cancellations included), so a caller can report it.
+	* Never rejects: the cloud sync fans this out over every integration and must not fail on one.
+	*/
+	syncCloudConnection(state, forceSync) {
+		return this.runSessionTransition(() => this.syncCloudConnectionLocked(state, forceSync));
+	}
+	async syncCloudConnectionLocked(state, forceSync) {
 		const scope = getScopedLogger();
 		if (this._session?.cloud === false && state !== "connected") {
 			if (this.id !== "github" && !this.skippedNonCloudReported) {
@@ -351,13 +404,13 @@ var IntegrationBase = class IntegrationBase {
 			}
 			return;
 		}
+		let failure;
 		switch (state) {
 			case "connected": {
 				const oldSession = this._session;
 				let resyncing = false;
 				if (forceSync) {
 					this.onStoredTokensReplaced();
-					this._session = void 0;
 					await this.ctx.storage.deleteWorkspace(this.connectedKey);
 					resyncing = true;
 				} else {
@@ -367,20 +420,24 @@ var IntegrationBase = class IntegrationBase {
 				let newSession;
 				let refetchFailed = false;
 				try {
-					newSession = await this.ensureSession({
+					newSession = await this.resolveSessionLocked({
 						sync: forceSync,
 						refetch: resyncing
 					});
 				} catch (ex) {
-					if (!isCancellationError(ex)) scope?.error(ex);
 					refetchFailed = true;
+					if (!isCancellationError(ex)) scope?.error(ex);
+					failure = toError(ex);
 				}
 				if (oldSession && newSession && newSession.accessToken !== oldSession.accessToken) this.resetRequestExceptionCount("all");
 				if (resyncing && newSession == null && !refetchFailed) await (await this.authenticationService.get(this.authProvider.id)).deleteSession(this.authProviderDescriptor, { preserveConfigured: false });
 				break;
 			}
-			case "disconnected": await this.disconnect({ silent: true });
+			case "disconnected": await this.disconnectLocked({ silent: true }, true);
 		}
+		this._resyncs++;
+		this._lastResyncFailure = failure;
+		return failure;
 	}
 	/**
 	* Credentials that passed {@link validateCredential} within the last minute. A probe already in flight is
@@ -544,24 +601,48 @@ var IntegrationBase = class IntegrationBase {
 		}
 		if (ex instanceof AuthenticationError && this._session?.cloud && !this.hasSessionSyncRequests()) {
 			this.requestSessionSyncForUsecase(syncReqUsecase);
-			this._session = {
-				...this._session,
-				expiresAt: /* @__PURE__ */ new Date(Date.now() - 1)
-			};
+			const refused = this._session.accessToken;
+			this.expireSessionIfToken(refused);
+			this.runSessionTransition(() => {
+				this.expireSessionIfToken(refused);
+				return Promise.resolve();
+			});
 			return false;
 		}
 		if (!(ex instanceof AuthenticationError) && !(ex instanceof RequestClientError)) return false;
 		this.trackRequestException(options);
 		return true;
 	}
+	expireSessionIfToken(accessToken) {
+		if (this._session?.accessToken !== accessToken || this.connectionExpired === true) return;
+		this._session = {
+			...this._session,
+			expiresAt: /* @__PURE__ */ new Date(Date.now() - 1)
+		};
+	}
+	/** Counts completed cloud re-syncs, so a refresh queued behind one reuses its outcome rather than running another. */
+	_resyncs = 0;
+	_lastResyncFailure;
 	missingExpirityReported = false;
-	async refreshSessionIfExpired(scope) {
-		if (this._session?.expiresAt != null && this._session.expiresAt < /* @__PURE__ */ new Date()) try {
-			await this.syncCloudConnection("connected", true);
-		} catch (ex) {
-			scope?.error(ex);
-		}
-		else if (this._session?.expiresAt == null && this.id !== "github" && !this.missingExpirityReported) {
+	/**
+	* Resolves the refresh's failure while the session it could not replace is still unusable, so a read can report
+	* that instead of reading with an expired token or as a missing connection.
+	*/
+	async refreshSessionIfExpired() {
+		if (this._session?.expiresAt != null && this._session.expiresAt < /* @__PURE__ */ new Date()) {
+			const resyncs = this._resyncs;
+			return this.runSessionTransition(async () => {
+				let failure;
+				if (this._resyncs !== resyncs) failure = this._lastResyncFailure;
+				else if (this._session != null && this.connectionExpired === true) try {
+					failure = await this.syncCloudConnectionLocked("connected", true);
+				} catch (ex) {
+					failure = toError(ex);
+				}
+				if (this._session == null || this.connectionExpired !== true) return void 0;
+				return failure ?? /* @__PURE__ */ new Error(`The ${this.name} session could not be refreshed`);
+			});
+		} else if (this._session?.expiresAt == null && this.id !== "github" && !this.missingExpirityReported) {
 			this.ctx.hooks?.session?.onRefreshSkipped?.({
 				id: this.id,
 				reason: "missing-expiry",
@@ -578,11 +659,36 @@ var IntegrationBase = class IntegrationBase {
 		}
 	}
 	async isConnected() {
-		return await this.getSession("integrations") != null;
+		const session = this._session === void 0 ? await this.ensureSession({
+			createIfNeeded: false,
+			source: "integrations"
+		}) : this._session;
+		return session != null && this.isSessionForIntegrationHost(session);
 	}
 	async ensureSession(options) {
+		if (options.createIfNeeded || options.forceNewSession) {
+			if (!await this.signIn(options)) return this._session ?? void 0;
+			return this.runSessionTransition(() => this.resolveSessionLocked({ createIfNeeded: false }));
+		}
+		return this.runSessionTransition(() => this.resolveSessionLocked(options));
+	}
+	/**
+	* Asks the auth provider for a session interactively, storing what it gets; whether one came back. A declined
+	* consent or any other failure is not one, and never throws: it is resolved, like any read, from storage.
+	*/
+	async signIn(options) {
+		if (this.ctx.config.isIntegrationsEnabled?.() === false) return false;
+		await this.ctx.storage.deleteWorkspace(this.connectedKey);
+		try {
+			return await (await this.authenticationService.get(this.authProvider.id)).getSession(this.authProviderDescriptor, options) != null;
+		} catch {
+			return false;
+		}
+	}
+	/** Resolves and publishes the session. Only ever runs inside a transition (see {@link runSessionTransition}). */
+	async resolveSessionLocked(options) {
 		const scope = getScopedLogger();
-		const { createIfNeeded, forceNewSession, source, sync, refetch } = options;
+		const { createIfNeeded, source, sync, refetch } = options;
 		if (this._session != null && !refetch) {
 			if (this.isSessionForIntegrationHost(this._session)) return this._session;
 			this._session = null;
@@ -590,7 +696,6 @@ var IntegrationBase = class IntegrationBase {
 		if (this.ctx.config.isIntegrationsEnabled?.() === false) return void 0;
 		if (createIfNeeded || sync) await this.ctx.storage.deleteWorkspace(this.connectedKey);
 		else if (this.ctx.storage.getWorkspace(this.connectedKey) === false) return;
-		const generation = this._sessionGeneration;
 		let session;
 		try {
 			session = await (await this.authenticationService.get(this.authProvider.id)).getSession(this.authProviderDescriptor, sync ? {
@@ -599,7 +704,6 @@ var IntegrationBase = class IntegrationBase {
 				source
 			} : {
 				createIfNeeded,
-				forceNewSession,
 				source
 			});
 			if (session?.expiresAt != null && session.expiresAt < /* @__PURE__ */ new Date()) session = null;
@@ -613,8 +717,6 @@ var IntegrationBase = class IntegrationBase {
 			}
 			session = null;
 		}
-		if (refetch) this._sessionGeneration++;
-		else if (generation !== this._sessionGeneration) return this._session ?? void 0;
 		if (session === void 0 && !createIfNeeded && !sync) await this.ctx.storage.deleteWorkspace(this.connectedKey);
 		this._session = session ?? null;
 		this.smoothifyRequestExceptionCount();
@@ -707,8 +809,7 @@ var IntegrationBase = class IntegrationBase {
 	}
 	async getLinkedIssueOrPullRequest(resource, link, options) {
 		const scope = getScopedLogger();
-		if (!(this.maybeConnected ?? await this.isConnected())) return void 0;
-		await this.refreshSessionIfExpired(scope);
+		if (await this.prepareSessionLookup() != null) return void 0;
 		return this.ctx.cache.getIssueOrPullRequest(link.key, options?.type, resource, this, () => ({ value: (async () => {
 			try {
 				const result = await this.getProviderLinkedIssueOrPullRequest(this._session, resource, link, options?.type);
@@ -774,7 +875,7 @@ var IntegrationBase = class IntegrationBase {
 				this.resetRequestExceptionCount("getCurrentAccount");
 				return account;
 			} catch (ex) {
-				if (isCancellationError(ex)) {
+				if (isCancellationError(ex) && !isProviderUnreachableError(ex)) {
 					cacheable.invalidate();
 					return;
 				}
@@ -806,8 +907,12 @@ var IntegrationBase = class IntegrationBase {
 	}
 	async getPullRequest(resource, id, options) {
 		const scope = getScopedLogger();
-		if (!(this.maybeConnected ?? await this.isConnected())) return void 0;
-		await this.refreshSessionIfExpired(scope);
+		const refreshFailure = await this.prepareSessionLookup();
+		if (refreshFailure === "unconnected") return void 0;
+		if (refreshFailure != null) {
+			if (options?.throwOnError) throw refreshFailure;
+			return;
+		}
 		return await this.ctx.cache.getPullRequest(id, resource, this, (cacheable) => ({ value: (async () => {
 			try {
 				const result = await this.getProviderPullRequest?.(this._session, resource, id);