@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

package/src/rules/static-feature-flags/__tests__/test.tsx

@@ -0,0 +1,135 @@
+import outdent from 'outdent';
+import { tester } from '../../../__tests__/utils/_tester';
+import rule from '../index';
+
+const errors = [{ messageId: 'FFLiteral' }];
+const options = ['ssOnly'];
+
+tester.run('feature-flags/static-feature-flags', rule, {
+	valid: [
+		{
+			code: outdent`
+                import { ff } from '@atlassian/jira-feature-flagging';
+
+                const isEnabled = ff('is.enabled');
+            `,
+		},
+		{
+			code: outdent`
+                import { getFeatureFlagClient } from '@atlassian/jira-feature-flagging';
+
+                const FLAG_NAME = 'flag';
+                const isEnabled = getFeatureFlagClient().getBooleanValue(FLAG_NAME);
+            `,
+		},
+		{
+			code: outdent`
+                import { fg } from '@atlassian/jira-feature-gating';
+
+                const isEnabled = fg('fg_enabled');
+            `,
+		},
+		{
+			code: outdent`
+                import { componentWithFF } from '@atlassian/jira-feature-flagging-utils';
+
+                export const Component = componentWithFF('is_redesign', NewComponent, OldComponent);
+            `,
+		},
+		{
+			name: 'When using ssOnly option, Launch Darkly functions can avoid static usage',
+			options,
+			code: outdent`
+            import { ff, getFeatureFlagValue, getMultivariateFeatureFlag } from '@atlassian/jira-feature-flagging';
+            import { fg } from '@atlassian/jira-feature-gating';
+            import { componentWithFF } from '@atlassian/jira-feature-flagging-utils';
+
+            const FLAG_NAME = 'flag';
+
+            const isEnabled = ff(FLAG_NAME);
+            const FFValue = getFeatureFlagValue(FLAG_NAME, 10);
+            const FFMultiValue = multiFFValuegetMultivariateFeatureFlag(FLAG_NAME, 10, [10, 20])
+            const Component = componentWithFF(FLAG_NAME, NewComponent, OldComponent);
+        `,
+		},
+	],
+	invalid: [
+		{
+			code: outdent`
+                import { ff } from '@atlassian/jira-feature-flagging';
+
+                const FLAG_NAME = 'flag';
+                const isEnabled = ff(FLAG_NAME);
+            `,
+			output: outdent`
+                import { ff } from '@atlassian/jira-feature-flagging';
+
+                const FLAG_NAME = 'flag';
+                const isEnabled = ff('flag');
+            `,
+			errors,
+		},
+		{
+			code: outdent`
+                import { FLAG_NAME } from 'names';
+                import { ff } from '@atlassian/jira-feature-flagging';
+
+                const isEnabled = ff(FLAG_NAME);
+            `,
+			errors,
+		},
+		{
+			code: outdent`
+                import { FLAG_NAME } from 'names';
+                import { fg } from '@atlassian/jira-feature-gating';
+
+                const isEnabled = fg(FLAG_NAME);
+            `,
+			errors,
+		},
+		{
+			code: outdent`
+                import { FLAG_NAME } from 'names';
+                import { expVal } from '@atlassian/jira-feature-experiments';
+
+                const isEnabled = expVal(FLAG_NAME, 'my_param', 'my_default_value');
+            `,
+			errors,
+		},
+		{
+			code: outdent`
+                import { FLAG_NAME } from 'names';
+                import { UNSAFE_noExposureExp } from '@atlassian/jira-feature-experiments';
+
+                const isEnabled = UNSAFE_noExposureExp(FLAG_NAME, 'my_param', 'my_default_value');
+            `,
+			errors,
+		},
+		{
+			code: outdent`
+                import { FLAG_NAME } from 'names';
+                import { componentWithFF } from '@atlassian/jira-feature-flagging-utils';
+
+                export const Component = componentWithFF(FLAG_NAME, NewComponent, OldComponent);
+            `,
+			errors,
+		},
+		{
+			name: 'When using ssOnly option, Statsig functions should be static',
+			options,
+			code: outdent`
+            import { fg } from '@atlassian/jira-feature-gating';
+
+            const FLAG_NAME = 'flag';
+            const isEnabled2 = fg(FLAG_NAME);
+        `,
+			output: outdent`
+            import { fg } from '@atlassian/jira-feature-gating';
+
+            const FLAG_NAME = 'flag';
+            const isEnabled2 = fg('flag');
+        `,
+			errors,
+		},
+	],
+});

package/src/rules/static-feature-flags/index.tsx

@@ -0,0 +1,103 @@
+import type { Rule } from 'eslint';
+import { FEATURE_API_IMPORT_SOURCES } from '../constants';
+import { getDef, isIdentifierImportedFrom, type Node } from '../utils';
+
+const IMPORT_SOURCES = new Set([
+	...FEATURE_API_IMPORT_SOURCES,
+	'@atlassian/jira-feature-flagging-utils',
+	'@atlassian/jira-feature-gate-component',
+	'@atlassian/jira-feature-gates-test-mocks',
+	'@atlassian/jira-feature-gates-storybook-mocks',
+]);
+
+// Any functions not in this list should be skipped for performance.
+const FUNCTION_NAMES = new Set([
+	'ff',
+	'fg',
+	'getFeatureFlagValue',
+	'getMultivariateFeatureFlag',
+	'componentWithFF',
+	'componentWithFG',
+	'passGate',
+	'withGate',
+	'expVal',
+	'expValEquals',
+	'UNSAFE_noExposureExp',
+	'mockExp',
+	'withExp',
+	'wasExperimentManuallyExposed',
+]);
+
+const STATSIG_ONLY_FUNCTION_NAMES = new Set([
+	'fg',
+	'componentWithFG',
+	'passGate',
+	'withGate',
+	'expVal',
+	'expValEquals',
+	'UNSAFE_noExposureExp',
+	'mockExp',
+	'withExp',
+	'wasExperimentManuallyExposed',
+]);
+
+const rule: Rule.RuleModule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/static-feature-flags/README.md',
+			description: 'Ensure feature flags or gates are static string literals',
+		},
+		fixable: 'code',
+		messages: {
+			FFLiteral:
+				'Use static string literal for `featureFlagName`. See https://team.atlassian.com/project/ATLAS-46997/about',
+		},
+	},
+	create(context) {
+		const targetedFunctionsSwitch =
+			context.options[0] === 'ssOnly' ? STATSIG_ONLY_FUNCTION_NAMES : FUNCTION_NAMES;
+
+		return {
+			// When they're not literals, show a message
+			'CallExpression[callee.type="Identifier"][arguments.length>0][arguments.0.type!="Literal"]': (
+				node: Node<any>,
+			) => {
+				if (node.type !== 'CallExpression') {
+					return;
+				}
+
+				if (
+					node.callee.type === 'Identifier' &&
+					(!targetedFunctionsSwitch.has(node.callee.name) ||
+						!isIdentifierImportedFrom(node.callee.name, IMPORT_SOURCES, context))
+				) {
+					return;
+				}
+
+				const nameArgument = node.arguments[0];
+				if (nameArgument.type === 'Identifier') {
+					const def = getDef(nameArgument.name, context);
+					if (def != null && def.type === 'Variable') {
+						const { value } = def.node.init as any;
+
+						context.report({
+							node: nameArgument,
+							messageId: 'FFLiteral',
+							fix: (fixer) => fixer.replaceText(nameArgument, `'${value}'`),
+						});
+
+						return;
+					}
+				}
+
+				context.report({
+					node: nameArgument,
+					messageId: 'FFLiteral',
+				});
+			},
+		};
+	},
+};
+
+export default rule;

package/src/rules/use-recommended-utils/README.md

@@ -0,0 +1,67 @@
+# Use `fg` instead of `FeatureGates.checkGate` (feature-flags/use-recommended-utils)
+
+`fg` method is recommended over `FeatureGates.checkGate`. The former is a wrapper to
+`FeatureGates.checkGate` with unit testing mocking capabilities.
+
+## Examples
+
+### Feature Gates
+
+👎 Examples of **incorrect** code for this rule: Gate is accessed with `FeatureGates.checkGate`
+
+```tsx
+import FeatureGates from '@atlaskit/feature-gate-js-client';
+
+export const getThing = () => {
+	if (FeatureGates.checkGate('my_gate')) {
+		return getNewThing();
+	}
+
+	return getOldThing();
+};
+```
+
+👍 Examples of **correct** code for this rule: Gate is accessed with `fg`
+
+```tsx
+import { fg } from '@atlassian/jira-feature-gating';
+
+export const getThing = () => {
+	if (fg('my_gate')) {
+		return getNewThing();
+	}
+
+	return getOldThing();
+};
+```
+
+### Experiments
+
+👎 Examples of **incorrect** code for this rule: experiment is accessed with
+`FeatureGates.getExperimentValue`
+
+```tsx
+import FeatureGates from '@atlaskit/feature-gate-js-client';
+
+export const getThing = () => {
+	if (FeatureGates.getExperimentValue('my_experiment', 'is_enabled', false)) {
+		return newThing();
+	}
+
+	return oldThing();
+};
+```
+
+👍 Examples of **correct** code for this rule: experiment is accessed with `expVal`
+
+```tsx
+import { expVal } from '@atlassian/jira-feature-experiments';
+
+export const getThing = () => {
+	if (expVal('my_experiment', 'is_enabled', false)) {
+		return newThing();
+	}
+
+	return oldThing();
+};
+```

package/src/rules/use-recommended-utils/__tests__/rule.test.tsx

@@ -0,0 +1,78 @@
+import outdent from 'outdent';
+import { tester } from '../../../__tests__/utils/_tester';
+import rule from '../index';
+
+tester.run('feature-flags/use-recommended-utils', rule, {
+	valid: [
+		{
+			name: 'Other `FeatureGate` methods are allowed',
+			code: outdent`
+                import FeatureGates from '@atlaskit/feature-gate-js-client';
+
+                FeatureGates.initialize();
+            `,
+		},
+		{
+			name: 'Use `fg` to access gates',
+			code: outdent`
+                import { fg } from '@atlassian/jira-feature-gating';
+
+                export const Component = () => {
+                    return fg('my_gate') ? <HelloWorld /> : null;
+                };
+            `,
+		},
+		{
+			name: 'Use `expVal` to access experiments',
+			code: outdent`
+            import { expVal } from '@atlassian/jira-feature-experiments';
+
+            export const getThing = () => {
+                if (expVal('my_experiment', 'is_enabled', false)) {
+                    return newThing();
+                }
+
+                return oldThing();
+            };
+            `,
+		},
+	],
+	invalid: [
+		{
+			name: '`checkGate` is not allowed',
+			code: outdent`
+                import FeatureGates from '@atlaskit/feature-gate-js-client';
+
+                export const Component = () => {
+                    return FeatureGates.checkGate('my_gate') ? <HelloWorld /> : null;
+                };
+            `,
+			errors: [
+				{
+					message:
+						'Please do not use FeatureGates.checkGate, use `fg` from `@atlaskit/platform-feature-flags` instead.',
+				},
+			],
+		},
+		{
+			name: '`getExperimentValue` is not allowed',
+			code: outdent`
+                import FeatureGates from '@atlaskit/feature-gate-js-client';
+
+                export const getThing = () => {
+                    if (FeatureGates.getExperimentValue('my_experiment', 'is_enabled', false)) {
+                        return newThing();
+                    }
+
+                    return oldThing();
+                };
+            `,
+			errors: [
+				{
+					message:
+						'Experimentation is not suported in platform feature flags, reach out to #help-statsig-switcheroo.',
+				},
+			],
+		},
+	],
+});

package/src/rules/use-recommended-utils/index.tsx

@@ -0,0 +1,57 @@
+import type { Rule } from 'eslint';
+import { isIdentifierImportedFrom, type Node } from '../utils';
+
+const BANNED_IMPORTS_SET = new Set(['@atlaskit/feature-gate-js-client']);
+
+const rule: Rule.RuleModule = {
+	meta: {
+		docs: {
+			url: 'https://stash.atlassian.com/projects/ATLASSIAN/repos/atlassian-frontend-monorepo/browse/platform/packages/platform/eslint-plugin/src/rules/ff/use-recommended-utils/README.md',
+			description: 'Prefer using the feature flag abstraction over direct statsig library.',
+		},
+		messages: {
+			notSupported:
+				'Experimentation is not suported in platform feature flags, reach out to #help-statsig-switcheroo.',
+			useRecommended:
+				'Please do not use FeatureGates.{{util}}, use {{recommended}} from {{lib}} instead.',
+		},
+		type: 'problem',
+	},
+	create(context) {
+		return {
+			'CallExpression > MemberExpression:matches([property.name="checkGate"])': (
+				node: Node<'MemberExpression'>,
+			) => {
+				if (
+					node.object.type === 'Identifier' &&
+					isIdentifierImportedFrom(node.object.name, BANNED_IMPORTS_SET, context)
+				) {
+					context.report({
+						messageId: 'useRecommended',
+						node,
+						data: {
+							lib: '`@atlaskit/platform-feature-flags`',
+							util: (node.property as any).name,
+							recommended: '`fg`',
+						},
+					});
+				}
+			},
+			'CallExpression > MemberExpression:matches([property.name="getExperimentValue"])': (
+				node: Node<'MemberExpression'>,
+			) => {
+				if (
+					node.object.type === 'Identifier' &&
+					isIdentifierImportedFrom(node.object.name, BANNED_IMPORTS_SET, context)
+				) {
+					context.report({
+						messageId: 'notSupported',
+						node,
+					});
+				}
+			},
+		};
+	},
+};
+
+export default rule;

package/src/rules/util/handle-ast-object.ts

@@ -1,44 +1,33 @@
-import type {
-  ObjectExpression,
-  SimpleLiteral,
-  RegExpLiteral,
-  BigIntLiteral,
-} from 'estree';
+import type { ObjectExpression, SimpleLiteral, RegExpLiteral, BigIntLiteral } from 'estree';
 
 export const getObjectPropertyAsLiteral = (
-  node: ObjectExpression,
-  property: string,
+	node: ObjectExpression,
+	property: string,
 ): SimpleLiteral['value'] | RegExpLiteral['value'] | BigIntLiteral['value'] => {
-  const prop = node.properties.find(
-    (p) =>
-      p.type === 'Property' &&
-      p.key.type === 'Literal' &&
-      p.key.value === property,
-  );
+	const prop = node.properties.find(
+		(p) => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === property,
+	);
 
-  // double check for property is to make typescript happy
-  if (prop?.type === 'Property' && prop?.value.type === 'Literal') {
-    return prop.value.value ?? null;
-  }
+	// double check for property is to make typescript happy
+	if (prop?.type === 'Property' && prop?.value.type === 'Literal') {
+		return prop.value.value ?? null;
+	}
 
-  return null;
+	return null;
 };
 
 export const getObjectPropertyAsObject = (
-  node: ObjectExpression,
-  property: string,
+	node: ObjectExpression,
+	property: string,
 ): ObjectExpression | null => {
-  const prop = node.properties.find(
-    (p) =>
-      p.type === 'Property' &&
-      p.key.type === 'Literal' &&
-      p.key.value === property,
-  );
+	const prop = node.properties.find(
+		(p) => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === property,
+	);
 
-  // double check for property is to make typescript happy
-  if (prop?.type === 'Property' && prop?.value.type === 'ObjectExpression') {
-    return prop.value ?? null;
-  }
+	// double check for property is to make typescript happy
+	if (prop?.type === 'Property' && prop?.value.type === 'ObjectExpression') {
+		return prop.value ?? null;
+	}
 
-  return null;
+	return null;
 };

package/src/rules/util/registration-utils.ts

@@ -5,54 +5,55 @@ import Fuse from 'fuse.js';
 // defines a "getter" to "type" map, if more types are required for feature flags (like string) add it here!
 // if you don't want to verify the type use `null` as the value
 export const getterIdentifierToFlagTypeMap = {
-  getBooleanFF: 'boolean' as const,
-  ffTest: 'boolean' as const,
+	getBooleanFF: 'boolean' as const,
+	ffTest: 'boolean' as const,
+	fg: 'boolean' as const,
 } as const;
 
 export type PlatformFeatureFlagRegistrationSection = {
-  [key: string]: {
-    // get the values of the object above
-    type: (typeof getterIdentifierToFlagTypeMap)[keyof typeof getterIdentifierToFlagTypeMap];
-  };
+	[key: string]: {
+		// get the values of the object above
+		type: (typeof getterIdentifierToFlagTypeMap)[keyof typeof getterIdentifierToFlagTypeMap];
+	};
 };
 
 export type EnhancedPackageJson = readPkgUp.PackageJson & {
-  'platform-feature-flags'?: PlatformFeatureFlagRegistrationSection;
+	'platform-feature-flags'?: PlatformFeatureFlagRegistrationSection;
 };
 
 export type PkgJsonMetaData = {
-  pkgJson: EnhancedPackageJson;
-  fuse: Fuse<string> | null;
+	pkgJson: EnhancedPackageJson;
+	fuse: Fuse<string> | null;
 };
 // make sure we cache reading the package.json so we don't end up reading it for every instance of this rule.
 const pkgJsonCache = new Map<string, PkgJsonMetaData>();
 // get the ancestor package.json for a given file
 export const getMetadataForFilename = (filename: string): PkgJsonMetaData => {
-  const splitFilename = filename.split(path.sep);
-  for (let i = 0; i < splitFilename.length; i++) {
-    // attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
-    const searchPath = path.join(...splitFilename.splice(0, i));
-    const cachedMetaData = pkgJsonCache.get(searchPath);
+	const splitFilename = filename.split(path.sep);
+	for (let i = 0; i < splitFilename.length; i++) {
+		// attempt to search using the filename in the cache to see if we've read the package.json for a sibling file before
+		const searchPath = path.join(...splitFilename.splice(0, i));
+		const cachedMetaData = pkgJsonCache.get(searchPath);
 
-    if (cachedMetaData) {
-      return cachedMetaData;
-    }
-  }
+		if (cachedMetaData) {
+			return cachedMetaData;
+		}
+	}
 
-  const { packageJson, path: pkgJsonPath } = readPkgUp.sync({
-    cwd: filename,
-    normalize: false,
-  })!;
+	const { packageJson, path: pkgJsonPath } = readPkgUp.sync({
+		cwd: filename,
+		normalize: false,
+	})!;
 
-  const pkgJson = packageJson as EnhancedPackageJson;
+	const pkgJson = packageJson as EnhancedPackageJson;
 
-  const fuse =
-    packageJson['platform-feature-flags'] == null
-      ? null
-      : new Fuse(Object.keys(pkgJson['platform-feature-flags']!));
+	const fuse =
+		packageJson['platform-feature-flags'] == null
+			? null
+			: new Fuse(Object.keys(pkgJson['platform-feature-flags']!));
 
-  const metaData = { pkgJson, fuse };
+	const metaData = { pkgJson, fuse };
 
-  pkgJsonCache.set(pkgJsonPath, metaData);
-  return metaData;
+	pkgJsonCache.set(pkgJsonPath, metaData);
+	return metaData;
 };

package/src/rules/utils.tsx

@@ -0,0 +1,46 @@
+import { FEATURE_API_IMPORT_SOURCES } from './constants';
+import type { Rule, Scope } from 'eslint';
+
+export function isIdentifierImportedFrom(
+	identifierName: string,
+	sources: Set<string>,
+	context: Rule.RuleContext,
+) {
+	if (sources.size > 0) {
+		return (
+			context
+				.getScope()
+				.references.find((ref) => ref.identifier.name === identifierName)
+				?.resolved?.defs.some(
+					(def) =>
+						def.parent?.type === 'ImportDeclaration' && sources.has(def.parent.source.value + ''),
+				) ?? false
+		);
+	}
+
+	return false;
+}
+
+export function isAPIimport(functionName: string, context: Rule.RuleContext) {
+	return isIdentifierImportedFrom(functionName, FEATURE_API_IMPORT_SOURCES, context);
+}
+
+// returns the definition node of a variable if it's declared within the scope of the file
+export function getDef(name: string, context: Rule.RuleContext) {
+	let scope: Scope.Scope | null = context.getScope();
+
+	while (scope && scope.type !== 'global') {
+		for (const variable of scope.variables) {
+			if (variable.name === name) {
+				const definition = variable.defs.find(
+					(def) => def.node && def.node.type === 'VariableDeclarator',
+				);
+				return definition;
+			}
+		}
+		scope = scope.upper;
+	}
+	return null;
+}
+
+export type Node<T extends Rule.Node['type']> = Extract<Rule.Node, { type: T }>;