Caches Org AI settings in local storage

(#4300, #4338)

Author: sergeibbb

src/constants.storage.ts

@@ -7,6 +7,7 @@ import type { GroupableTreeViewTypes } from './constants.views';
 import type { Environment } from './container';
 import type { FeaturePreviews } from './features';
 import type { GitRevisionRangeNotation } from './git/models/revision';
+import type { OrganizationSettings } from './plus/gk/models/organization';
 import type { PaidSubscriptionPlanIds, Subscription } from './plus/gk/models/subscription';
 import type { IntegrationConnectedKey } from './plus/integrations/models/integration';
 import type { DeepLinkServiceState } from './uris/deepLinks/deepLink';
@@ -89,6 +90,10 @@ export type GlobalStorage = {
 	'views:scm:grouped:welcome:dismissed': boolean;
 	'integrations:configured': StoredIntegrationConfigurations;
 } & { [key in `plus:preview:${FeaturePreviews}:usages`]: StoredFeaturePreviewUsagePeriod[] } & {
+	[key in `plus:organization:${string}:settings`]: Stored<
+		(OrganizationSettings & { lastValidatedAt: number }) | undefined
+	>;
+} & {
 	[key in `provider:authentication:skip:${string}`]: boolean;
 } & { [key in `gk:${string}:checkin`]: Stored<StoredGKCheckInResponse> } & {
 	[key in `gk:${string}:organizations`]: Stored<StoredOrganization[]>;

src/plus/gk/organizationService.ts

@@ -20,7 +20,9 @@ const organizationsCacheExpiration = 24 * 60 * 60 * 1000; // 1 day
 export class OrganizationService implements Disposable {
 	private _disposable: Disposable;
 	private _organizations: Organization[] | null | undefined;
-	private _organizationSettings: Map<Organization['id'], OrganizationSettings> | undefined;
+	private _organizationSettings:
+		| Map<Organization['id'], { data: OrganizationSettings; lastValidatedDate: Date }>
+		| undefined;
 	private _organizationMembers: Map<Organization['id'], OrganizationMember[]> | undefined;
 
 	constructor(
@@ -126,11 +128,12 @@ export class OrganizationService implements Disposable {
 		});
 	}
 
-	private onSubscriptionChanged(e: SubscriptionChangeEvent): void {
+	private async onSubscriptionChanged(e: SubscriptionChangeEvent): Promise<void> {
 		if (e.current?.account?.id == null) {
 			this.updateOrganizations(undefined);
 		}
-		void this.updateOrganizationPermissions(e.current?.activeOrganization?.id);
+		await this.clearAllStoredOrganizationsSettings();
+		await this.updateOrganizationPermissions(e.current?.activeOrganization?.id);
 	}
 
 	private updateOrganizations(organizations: Organization[] | null | undefined): void {
@@ -217,7 +220,23 @@ export class OrganizationService implements Disposable {
 		const id = orgId ?? (await this.getActiveOrganizationId());
 		if (id == null) return undefined;
 
+		if (!options?.force && !this._organizationSettings?.has(id)) {
+			const cachedOrg = this.getStoredOrganizationSettings(id);
+			if (cachedOrg) {
+				this._organizationSettings ??= new Map();
+				this._organizationSettings.set(id, cachedOrg);
+			}
+		}
+
+		if (this._organizationSettings?.has(id)) {
+			const org = this._organizationSettings.get(id);
+			if (org && Date.now() - org.lastValidatedDate.getTime() > organizationsCacheExpiration) {
+				this._organizationSettings.delete(id);
+			}
+		}
+
 		if (!this._organizationSettings?.has(id) || options?.force === true) {
+			await this.deleteStoredOrganizationSettings(id);
 			const rsp = await this.connection.fetchGkApi(
 				`v1/organizations/settings`,
 				{ method: 'GET' },
@@ -245,9 +264,43 @@ export class OrganizationService implements Disposable {
 			if (this._organizationSettings == null) {
 				this._organizationSettings = new Map();
 			}
-			this._organizationSettings.set(id, organizationResponse.data);
+			this._organizationSettings.set(id, { data: organizationResponse.data, lastValidatedDate: new Date() });
+			await this.storeOrganizationSettings(id, organizationResponse.data, new Date());
 		}
-		return this._organizationSettings.get(id);
+		return this._organizationSettings.get(id)?.data;
+	}
+
+	private async clearAllStoredOrganizationsSettings(): Promise<void> {
+		return this.container.storage.deleteWithPrefix(`plus:organization:`);
+	}
+
+	private async deleteStoredOrganizationSettings(id: string): Promise<void> {
+		return this.container.storage.delete(`plus:organization:${id}:settings`);
+	}
+
+	private getStoredOrganizationSettings(
+		id: string,
+	): { data: OrganizationSettings; lastValidatedDate: Date } | undefined {
+		const result = this.container.storage.get(`plus:organization:${id}:settings`);
+		if (!result?.data) return undefined;
+
+		const { lastValidatedAt, ...organizationSettings } = result.data;
+
+		return {
+			data: organizationSettings,
+			lastValidatedDate: new Date(lastValidatedAt),
+		};
+	}
+
+	private async storeOrganizationSettings(
+		id: string,
+		settings: OrganizationSettings,
+		lastValidatedDate: Date,
+	): Promise<void> {
+		return this.container.storage.store(`plus:organization:${id}:settings`, {
+			v: 1,
+			data: { ...settings, lastValidatedAt: lastValidatedDate.getTime() },
+		});
 	}
 }