Merge pull request #32 from launchdarkly/2.2.1

Release 2.2.1

Author: Arnold Trakhtenberg

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to the "launchdarkly" extension will be documented in this file.
 
+## [2.2.1] - 2020-02-19
+
+### Added
+
+- The hover display surfaces the feature flag's name
+
 ## [2.2.0] - 2020-01-06
 
 ### Added

package.json

@@ -2,7 +2,7 @@
 	"name": "launchdarkly",
 	"displayName": "LaunchDarkly",
 	"description": "View LaunchDarkly feature flags in your editor.",
-	"version": "2.2.0",
+	"version": "2.2.1",
 	"publisher": "launchdarkly",
 	"engines": {
 		"vscode": "^1.34.0"

src/flagStore.ts

@@ -5,7 +5,7 @@ import StreamProcessor = require('launchdarkly-node-server-sdk/streaming');
 import Requestor = require('launchdarkly-node-server-sdk/requestor');
 import { debounce } from 'lodash';
 
-import { FlagConfiguration } from './models';
+import { Flag, FlagConfiguration, FlagWithConfiguration } from './models';
 import { Configuration } from './configuration';
 import { LaunchDarklyAPI } from './api';
 
@@ -15,6 +15,8 @@ const DATA_KIND = { namespace: 'features' };
 export class FlagStore {
 	private readonly config: Configuration;
 	private readonly store: LDFeatureStore;
+	private readonly flagMetadata: { [key: string]: Flag } = {};
+
 	private readonly api: LaunchDarklyAPI;
 	private readonly streamingConfigOptions = ['accessToken', 'baseUri', 'streamUri', 'project', 'env'];
 	private updateProcessor: LDStreamProcessor;
@@ -114,6 +116,27 @@ export class FlagStore {
 		};
 	}
 
+	getFeatureFlag(key: string): Promise<FlagWithConfiguration | null> {
+		let flag = this.flagMetadata[key];
+		return new Promise((resolve, reject) => {
+			this.store.get(DATA_KIND, key, async (res: FlagConfiguration) => {
+				if (!res) {
+					resolve(null);
+				}
+				if (!flag || flag.environments[this.config.env].version < res.version) {
+					try {
+						flag = await this.api.getFeatureFlag(this.config.project, key, this.config.env);
+						this.flagMetadata[key] = flag;
+						resolve({ flag, config: res });
+					} catch (e) {
+						console.error(`Could not retrieve feature flag metadata for ${key}: ${e}`);
+						reject(e);
+					}
+				}
+			});
+		});
+	}
+
 	allFlags(): Promise<FlagConfiguration[]> {
 		return new Promise(resolve => {
 			this.store.all(DATA_KIND, resolve);

src/models.ts

@@ -10,6 +10,7 @@ export class Project extends Resource {
 
 export class Environment extends Resource {
 	apiKey: string;
+	version: number;
 	_site: { href: string };
 }
 
@@ -26,4 +27,10 @@ export class FlagConfiguration {
 	targets: any;
 	rules: Array<any>;
 	on: boolean;
+	version: number;
+}
+
+export class FlagWithConfiguration {
+	flag: Flag;
+	config: FlagConfiguration;
 }

src/providers.ts

@@ -20,7 +20,7 @@ import { kebabCase } from 'lodash';
 import { Configuration } from './configuration';
 import { ConfigurationMenu } from './configurationMenu';
 import { LaunchDarklyAPI } from './api';
-import { Environment, FlagConfiguration } from './models';
+import { Environment, Flag, FlagConfiguration } from './models';
 import { FlagStore } from './flagStore';
 
 const STRING_DELIMETERS = ['"', "'", '`'];
@@ -80,13 +80,13 @@ export function register(ctx: ExtensionContext, config: Configuration, flagStore
 			}
 
 			try {
-				await openFlagInBrowser(config, flagKey, api);
+				await openFlagInBrowser(config, flagKey, flagStore);
 			} catch (err) {
 				let errMsg = `Encountered an unexpected error retrieving the flag ${flagKey}`;
 				if (err.statusCode == 404) {
 					// Try resolving the flag key to kebab case
 					try {
-						await openFlagInBrowser(config, kebabCase(flagKey), api);
+						await openFlagInBrowser(config, kebabCase(flagKey), flagStore);
 						return;
 					} catch (err) {
 						if (err.statusCode == 404) {
@@ -113,13 +113,18 @@ class LaunchDarklyHoverProvider implements HoverProvider {
 	public provideHover(document: TextDocument, position: Position): Thenable<Hover> {
 		return new Promise(async (resolve, reject) => {
 			if (this.config.enableHover) {
-				const flags = await this.flagStore.allFlags();
 				let candidate = document.getText(document.getWordRangeAtPosition(position, FLAG_KEY_REGEX));
-				let flag = flags[candidate] || flags[kebabCase(candidate)];
-				if (flag) {
-					let hover = generateHoverString(flag);
-					resolve(new Hover(hover));
-					return;
+				try {
+					let data =
+						(await this.flagStore.getFeatureFlag(candidate)) ||
+						(await this.flagStore.getFeatureFlag(kebabCase(candidate)));
+					if (data) {
+						let hover = generateHoverString(data.flag, data.config);
+						resolve(new Hover(hover));
+						return;
+					}
+				} catch (e) {
+					reject(e);
 				}
 			}
 			reject();
@@ -154,8 +159,8 @@ class LaunchDarklyCompletionItemProvider implements CompletionItemProvider {
 	}
 }
 
-const openFlagInBrowser = async (config: Configuration, flagKey: string, api: LaunchDarklyAPI) => {
-	const flag = await api.getFeatureFlag(config.project, flagKey, config.env);
+const openFlagInBrowser = async (config: Configuration, flagKey: string, flagStore: FlagStore) => {
+	const { flag } = await flagStore.getFeatureFlag(flagKey);
 
 	// Default to first environment
 	let env: Environment = Object.values(flag.environments)[0];
@@ -174,19 +179,20 @@ const openFlagInBrowser = async (config: Configuration, flagKey: string, api: La
 	opn(url.resolve(config.baseUri, sitePath));
 };
 
-export function generateHoverString(flag: FlagConfiguration) {
+export function generateHoverString(flag: Flag, c: FlagConfiguration) {
 	return `**LaunchDarkly feature flag**\n
-	Key: ${flag.key}
-	Enabled: ${flag.on}
-	Default variation: ${JSON.stringify(flag.variations[flag.fallthrough.variation])}
-	Off variation: ${JSON.stringify(flag.variations[flag.offVariation])}
-	${plural(flag.prerequisites.length, 'prerequisite', 'prerequisites')}
+	Name: ${flag.name}
+	Key: ${c.key}
+	Enabled: ${c.on}
+	Default variation: ${JSON.stringify(c.variations[c.fallthrough.variation])}
+	Off variation: ${JSON.stringify(c.variations[c.offVariation])}
+	${plural(c.prerequisites.length, 'prerequisite', 'prerequisites')}
 	${plural(
-		flag.targets.reduce((acc, curr) => acc + curr.values.length, 0),
+		c.targets.reduce((acc, curr) => acc + curr.values.length, 0),
 		'user target',
 		'user targets',
 	)}
-	${plural(flag.rules.length, 'rule', 'rules')}`;
+	${plural(c.rules.length, 'rule', 'rules')}`;
 }
 
 function plural(count: number, singular: string, plural: string) {

test/providers.test.ts

@@ -1,9 +1,18 @@
 import * as assert from 'assert';
-import * as providers from '../src/providers';
 import * as path from 'path';
 import * as vscode from 'vscode';
 
-const flag = {
+import * as providers from '../src/providers';
+import { Flag, FlagConfiguration } from '../src/models';
+
+const flag: Flag = {
+	name: "Test",
+	key: "test",
+	tags: [],
+	environments: null,
+}
+
+const flagConfig: FlagConfiguration = {
 	key: 'test',
 	on: true,
 	variations: ['SomeVariation', { thisIsJson: 'AnotherVariation' }],
@@ -14,15 +23,16 @@ const flag = {
 	prerequisites: ['something'],
 	targets: [{ values: ['user', 'anotheruser'] }, { values: ['someotheruser'] }],
 	rules: [],
+	version: 1,
 };
 
 let testPath = path.join(__dirname, '..', '..', 'test');
 
 suite('provider utils tests', () => {
 	test('generateHoverString', () => {
 		assert.equal(
-			`**LaunchDarkly feature flag**\n\n\tKey: test\n\tEnabled: true\n\tDefault variation: "SomeVariation"\n\tOff variation: {"thisIsJson":"AnotherVariation"}\n\t1 prerequisite\n\t3 user targets\n\t0 rules`,
-			providers.generateHoverString(flag),
+			`**LaunchDarkly feature flag**\n\n\tName: Test\n\tKey: test\n\tEnabled: true\n\tDefault variation: "SomeVariation"\n\tOff variation: {"thisIsJson":"AnotherVariation"}\n\t1 prerequisite\n\t3 user targets\n\t0 rules`,
+			providers.generateHoverString(flag, flagConfig),
 		);
 	});