Adds plan restriction to promos

 - Supports plan-based promos

Author: eamodio

.gitignore

@@ -8,4 +8,5 @@ out
 node_modules
 images/settings
 gitlens-*.vsix
+product.json
 tsconfig*.tsbuildinfo

src/commands/quickCommand.steps.ts

@@ -43,7 +43,7 @@ import {
 } from '../git/utils/reference.utils';
 import { getHighlanderProviderName } from '../git/utils/remote.utils';
 import { createRevisionRange, isRevisionRange } from '../git/utils/revision.utils';
-import { isSubscriptionPaidPlan } from '../plus/gk/utils/subscription.utils';
+import { getSubscriptionNextPaidPlanId, isSubscriptionPaidPlan } from '../plus/gk/utils/subscription.utils';
 import type { LaunchpadCommandArgs } from '../plus/launchpad/launchpad';
 import {
 	CommitApplyFileChangesCommandQuickPickItem,
@@ -2753,7 +2753,11 @@ export async function* ensureAccessStep<
 	} else {
 		if (access.subscription.required == null) return access;
 
-		const promo = await container.productConfig.getApplicablePromo(access.subscription.current.state, 'gate');
+		const promo = await container.productConfig.getApplicablePromo(
+			access.subscription.current.state,
+			getSubscriptionNextPaidPlanId(access.subscription.current),
+			'gate',
+		);
 		const detail = promo?.content?.quickpick.detail;
 
 		switch (feature) {

src/constants.storage.ts

@@ -7,7 +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 { Subscription } from './plus/gk/models/subscription';
+import type { PaidSubscriptionPlanIds, Subscription } from './plus/gk/models/subscription';
 import type { Integration } from './plus/integrations/models/integration';
 import type { DeepLinkServiceState } from './uris/deepLinks/deepLink';
 
@@ -120,8 +120,9 @@ export interface StoredProductConfig {
 export interface StoredPromo {
 	key: string;
 	code?: string;
-	locations?: ('account' | 'badge' | 'gate' | 'home')[];
+	plan?: PaidSubscriptionPlanIds;
 	states?: SubscriptionState[];
+	locations?: ('account' | 'badge' | 'gate' | 'home')[];
 	expiresOn?: number;
 	startsOn?: number;
 	percentile?: number;

src/features.ts

@@ -103,8 +103,12 @@ export function isProFeature(feature: PlusFeatures): feature is ProFeatures {
 
 export function isAdvancedFeature(feature: PlusFeatures): feature is AdvancedFeatures {
 	switch (feature) {
+		case 'explain-changes':
 		case 'generate-changelog':
+		case 'generate-create-cloudPatch':
+		case 'generate-create-codeSuggestion':
 		case 'generate-create-pullRequest':
+		case 'generate-rebase':
 			return true;
 		default:
 			return false;
@@ -116,9 +120,6 @@ export function isProFeatureOnAllRepos(feature: PlusFeatures): feature is ProFea
 		case 'launchpad':
 		case 'startWork':
 		case 'associateIssueWithBranch':
-		case 'explain-changes':
-		case 'generate-create-cloudPatch':
-		case 'generate-create-codeSuggestion':
 		case 'generate-stashMessage':
 			return true;
 		default:

src/plus/ai/aiProviderService.ts

@@ -493,8 +493,8 @@ export class AIProviderService implements Disposable {
 			!(await ensureFeatureAccess(
 				this.container,
 				isAdvancedFeature(feature)
-					? `Advanced AI features require a trial or GitLens Advanced.`
-					: `Pro AI features require a trial or GitLens Pro.`,
+					? 'This AI feature requires GitLens Advanced or a Pro trial'
+					: 'This AI feature requires GitLens Pro or a Pro trial',
 				feature,
 				source,
 			))

src/plus/gk/models/promo.ts

@@ -1,18 +1,22 @@
 import type { GlCommands } from '../../../constants.commands';
 import type { SubscriptionState } from '../../../constants.subscription';
+import type { PaidSubscriptionPlanIds } from './subscription';
 
-export type PromoLocation = 'account' | 'badge' | 'gate' | 'home';
 export type PromoKeys = 'pro50' | (string & {});
+export type PromoLocation = 'account' | 'badge' | 'gate' | 'home';
+export type PromoPlans = PaidSubscriptionPlanIds;
 
 export interface Promo {
 	readonly key: PromoKeys;
 	readonly code?: string;
+	readonly plan: PromoPlans;
 	readonly states?: SubscriptionState[];
 	readonly expiresOn?: number;
 	readonly startsOn?: number;
 
 	readonly locations?: PromoLocation[];
 	readonly content?: {
+		readonly modal: { readonly detail: string };
 		readonly quickpick: { readonly detail: string };
 		readonly webview?: {
 			readonly info?: {

src/plus/gk/models/subscription.ts

@@ -49,7 +49,7 @@ export interface SubscriptionAccount {
 }
 
 export interface SubscriptionUpgradeCommandArgs extends Source {
-	plan?: SubscriptionPlanIds;
+	plan?: PaidSubscriptionPlanIds;
 }
 
 export type SubscriptionStateString =

src/plus/gk/productConfigProvider.ts

@@ -8,18 +8,26 @@ import { getLoggableName, Logger } from '../../system/logger';
 import { startLogScope } from '../../system/logger.scope';
 import type { Validator } from '../../system/validation';
 import { createValidator, Is } from '../../system/validation';
-import type { Promo, PromoLocation } from './models/promo';
+import type { Promo, PromoLocation, PromoPlans } from './models/promo';
 import type { ServerConnection } from './serverConnection';
 
 type Config = {
 	promos: Promo[];
 };
 
 type ConfigJson = {
-	v: number;
-	promos: PromoJson[];
+	/** @deprecated this doesn't provide value, but we need to keep it for old clients */
+	v?: number;
+	promos?: PromoJson[];
+	promosV2?: PromoV2Json[];
 };
-type PromoJson = Replace<Promo, 'expiresOn' | 'startsOn', string | undefined>;
+type PromoJson = Replace<Promo, 'plan' | 'expiresOn' | 'startsOn', string | undefined> & {
+	v?: number;
+	plan?: PromoPlans;
+};
+type PromoV2Json = Replace<Promo, 'expiresOn' | 'startsOn', string | undefined> & { v: number | undefined };
+
+const maxKnownPromoVersion = 2;
 
 export class ProductConfigProvider {
 	private readonly _lazyConfig: Lazy<Promise<Config>>;
@@ -35,32 +43,25 @@ export class ProductConfigProvider {
 				statusCode: undefined as number | undefined,
 			};
 
+			if (DEBUG) {
+				try {
+					// eslint-disable-next-line @typescript-eslint/ban-ts-comment -- using @ts-ignore instead of @ts-expect-error because if `product.json` is found then @ts-expect-error will complain because its not an error anymore
+					// @ts-ignore
+					const data = (await import('../../../product.json', { with: { type: 'json' } })).default;
+					const config = getConfig(data);
+					if (config != null) return config;
+
+					debugger;
+				} catch {}
+			}
+
 			try {
 				const rsp = await connection.fetchGkConfig('product.json');
 				if (rsp.ok) {
 					data = await rsp.json();
 
-					const validator = createConfigValidator();
-					if (validator(data)) {
-						const promos = data.promos.map(
-							d =>
-								({
-									key: d.key,
-									code: d.code,
-									states: d.states,
-									expiresOn: d.expiresOn == null ? undefined : new Date(d.expiresOn).getTime(),
-									startsOn: d.startsOn == null ? undefined : new Date(d.startsOn).getTime(),
-									locations: d.locations,
-									content: d.content,
-									percentile: d.percentile,
-								}) satisfies Promo,
-						);
-
-						const config: Config = { promos: promos };
-						await container.storage.store('product:config', { data: config, v: 1, timestamp: Date.now() });
-
-						return config;
-					}
+					const config = getConfig(data);
+					if (config != null) return config;
 
 					failed.validation = true;
 				} else {
@@ -80,13 +81,19 @@ export class ProductConfigProvider {
 			});
 
 			const stored = container.storage.get('product:config');
-			if (stored?.data != null) return stored.data;
+			if (stored?.data != null) {
+				return {
+					...stored.data,
+					promos: stored.data.promos.map(p => ({ ...p, plan: p.plan ?? 'pro' }) satisfies Promo),
+				} satisfies Config;
+			}
 
 			// If all else fails, return a default set of promos
 			return {
 				promos: [
 					{
 						key: 'pro50',
+						plan: 'pro',
 						states: [
 							SubscriptionState.Community,
 							SubscriptionState.Trial,
@@ -95,13 +102,10 @@ export class ProductConfigProvider {
 						],
 						locations: ['home', 'account', 'badge', 'gate'],
 						content: {
-							quickpick: {
-								detail: '$(star-full) Save 50% on GitLens Pro',
-							},
+							modal: { detail: 'Save 50% on GitLens Pro' },
+							quickpick: { detail: '$(star-full) Save 50% on GitLens Pro' },
 							webview: {
-								info: {
-									html: '<b>Save 50%</b> on GitLens Pro',
-								},
+								info: { html: '<b>Save 50%</b> on GitLens Pro' },
 								link: {
 									html: '<b>Save 50%</b> on GitLens Pro',
 									title: 'Upgrade now and Save 50% on GitLens Pro',
@@ -114,11 +118,15 @@ export class ProductConfigProvider {
 		});
 	}
 
-	async getApplicablePromo(state: number | undefined, location?: PromoLocation): Promise<Promo | undefined> {
+	async getApplicablePromo(
+		state: SubscriptionState | undefined,
+		plan: PromoPlans,
+		location?: PromoLocation,
+	): Promise<Promo | undefined> {
 		if (state == null) return undefined;
 
 		const promos = await this.getPromos();
-		return getApplicablePromo(promos, state, location);
+		return getApplicablePromo(promos, state, plan, location);
 	}
 
 	private getConfig(): Promise<Config> {
@@ -145,6 +153,10 @@ function createConfigValidator(): Validator<ConfigJson> {
 		SubscriptionState.Paid,
 	);
 
+	const isModal = createValidator({
+		detail: Is.String,
+	});
+
 	const isQuickPick = createValidator({
 		detail: Is.String,
 	});
@@ -168,11 +180,14 @@ function createConfigValidator(): Validator<ConfigJson> {
 	});
 
 	const isContent = createValidator({
+		modal: isModal,
 		quickpick: isQuickPick,
 		webview: Is.Optional(isWebview),
 	});
 
 	const promoValidator = createValidator<PromoJson>({
+		v: Is.Optional(Is.Number),
+		plan: Is.Optional(Is.Enum<PromoPlans>('pro', 'advanced', 'teams', 'enterprise')),
 		key: Is.String,
 		code: Is.Optional(Is.String),
 		states: Is.Optional(Is.Array(isState)),
@@ -183,17 +198,36 @@ function createConfigValidator(): Validator<ConfigJson> {
 		percentile: Is.Optional(Is.Number),
 	});
 
-	return createValidator<ConfigJson>({
+	const promoV2Validator = createValidator<PromoV2Json>({
 		v: Is.Number,
-		promos: Is.Array(promoValidator),
+		key: Is.String,
+		code: Is.Optional(Is.String),
+		plan: Is.Enum<PromoPlans>('pro', 'advanced', 'teams', 'enterprise'),
+		states: Is.Optional(Is.Array(isState)),
+		expiresOn: Is.Optional(Is.String),
+		startsOn: Is.Optional(Is.String),
+		locations: Is.Optional(Is.Array(isLocation)),
+		content: Is.Optional(isContent),
+		percentile: Is.Optional(Is.Number),
+	});
+
+	return createValidator<ConfigJson>({
+		v: Is.Optional(Is.Number),
+		promos: Is.Optional(Is.Array(promoValidator)),
+		promosV2: Is.Optional(Is.Array(promoV2Validator)),
 	});
 }
 
-function getApplicablePromo(promos: Promo[], state: number | undefined, location?: PromoLocation): Promo | undefined {
+function getApplicablePromo(
+	promos: Promo[],
+	state: SubscriptionState | undefined,
+	plan: PromoPlans,
+	location?: PromoLocation,
+): Promo | undefined {
 	if (state == null) return undefined;
 
 	for (const promo of promos) {
-		if (isPromoApplicable(promo, state)) {
+		if (isPromoApplicable(promo, state, plan)) {
 			if (location == null || promo.locations == null || promo.locations.includes(location)) {
 				return promo;
 			}
@@ -204,10 +238,37 @@ function getApplicablePromo(promos: Promo[], state: number | undefined, location
 	return undefined;
 }
 
-function isPromoApplicable(promo: Promo, state: number): boolean {
+function getConfig(data: unknown): Config | undefined {
+	const validator = createConfigValidator();
+	if (!validator(data)) return undefined;
+
+	const promos = (data.promosV2 ?? data.promos ?? [])
+		// Filter out promos that we don't know how to handle
+		.filter(d => d.v == null || d.v <= maxKnownPromoVersion)
+		.map(
+			d =>
+				({
+					key: d.key,
+					code: d.code,
+					plan: d.plan ?? 'pro',
+					states: d.states,
+					expiresOn: d.expiresOn == null ? undefined : new Date(d.expiresOn).getTime(),
+					startsOn: d.startsOn == null ? undefined : new Date(d.startsOn).getTime(),
+					locations: d.locations,
+					content: d.content,
+					percentile: d.percentile,
+				}) satisfies Promo,
+		);
+
+	const config: Config = { promos: promos };
+	return config;
+}
+
+function isPromoApplicable(promo: Promo, state: SubscriptionState, plan: PromoPlans): boolean {
 	const now = Date.now();
 
 	return (
+		(promo.plan == null || promo.plan === plan) &&
 		(promo.states == null || promo.states.includes(state)) &&
 		(promo.expiresOn == null || promo.expiresOn > now) &&
 		(promo.startsOn == null || promo.startsOn < now) &&