@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

package/src/rules/no-alias/README.md

@@ -0,0 +1,29 @@
+# Avoid aliasing feature flag utils (feature-flags/no-alias)
+
+Ensure feature flag usage is statically analyzable. This applies to all methods, weather you are
+writing production code, unit testing or storybooks.
+
+## Examples
+
+👎 Examples of **incorrect** code for this rule:
+
+```tsx
+// Do not alias utils
+import { ff as getBoolean } from '@atlassian/jira-feature-flagging';
+
+// Do not reassign utils
+import { fg } from '@atlassian/jira-feature-gating';
+const aliasedFG = fg;
+```
+
+👍 Examples of **correct** code for this rule: Do not alias utils
+
+```tsx
+import { ff } from '@atlassian/jira-feature-flagging';
+
+export const doSomething = () => {
+	if (ff('my.flag')) {
+		console.log('hello');
+	}
+};
+```

package/src/rules/no-alias/__tests__/rule.test.tsx

@@ -0,0 +1,76 @@
+import outdent from 'outdent';
+import { tester } from '../../../__tests__/utils/_tester';
+import rule from '../index';
+
+tester.run('feature-flags/no-alias', rule, {
+	valid: [
+		{
+			name: '`@atlassian/jira-feature-flagging` imports are not aliased',
+			code: outdent`
+                import { ff, ffVal } from '@atlassian/jira-feature-flagging';
+            `,
+		},
+		{
+			name: '`@atlassian/jira-feature-flagging-utils` imports are not aliased',
+			code: outdent`
+                import { componentWithFF } from '@atlassian/jira-feature-flagging-utils';
+            `,
+		},
+		{
+			name: '`@atlassian/jira-feature-gating` imports are not aliased',
+			code: outdent`
+                import { fg } from '@atlassian/jira-feature-gating';
+            `,
+		},
+		{
+			name: '`@atlassian/jira-feature-gates-test-mocks` imports are not aliased',
+			code: outdent`
+                import { passGate } from '@atlassian/jira-feature-gates-test-mocks';
+            `,
+		},
+		{
+			name: '`@atlassian/jira-feature-gates-storybook-mocks` imports are not aliased',
+			code: outdent`
+                import { withGate } from '@atlassian/jira-feature-gates-storybook-mocks';
+            `,
+		},
+		{
+			name: 'Aliases for non related imports are allowed',
+			code: outdent`
+                import { memo as m } from 'react';
+                import * as r from 'redux';
+            `,
+		},
+	],
+	invalid: [
+		{
+			name: 'Do not alias utils',
+			code: outdent`
+                import { ff as getBoolean } from '@atlassian/jira-feature-flagging';
+            `,
+			errors: [{ messageId: 'noSpecifierAlias' }],
+		},
+		{
+			name: 'Do not alias multiple utils',
+			code: outdent`
+                import { ff as getBoolean, ffVal as getFeatureFlagValue } from '@atlassian/jira-feature-flagging';
+            `,
+			errors: [{ messageId: 'noSpecifierAlias' }, { messageId: 'noSpecifierAlias' }],
+		},
+		{
+			name: 'Do not allow namespace imports',
+			code: outdent`
+                import * as ffUtils from '@atlassian/jira-feature-flagging';
+            `,
+			errors: [{ messageId: 'noNamespaceSpecifier' }],
+		},
+		{
+			name: 'Do not reassign utils',
+			code: outdent`
+                import { fg } from '@atlassian/jira-feature-gating';
+                const aliasedFG = fg;
+            `,
+			errors: [{ messageId: 'noReassignment' }],
+		},
+	],
+});

package/src/rules/no-alias/index.tsx

@@ -0,0 +1,75 @@
+import type { Rule } from 'eslint';
+import {
+	FEATURE_API_IMPORT_SOURCES,
+	FEATURE_MOCKS_IMPORT_SOURCES,
+	FEATURE_UTILS_IMPORT_SOURCES,
+} from '../constants';
+import { isIdentifierImportedFrom, type Node } from '../utils';
+
+const IMPORT_SOURCES = new Set([
+	...FEATURE_API_IMPORT_SOURCES,
+	...FEATURE_MOCKS_IMPORT_SOURCES,
+	...FEATURE_UTILS_IMPORT_SOURCES,
+]);
+
+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/no-alias/README.md',
+			description:
+				'Disallow aliasing of feature flag utils to ensure feature flag usage is statically analyzable',
+		},
+		messages: {
+			noSpecifierAlias:
+				'Do not alias feature flag utils. Feature flag usage should be statically analyzable',
+			noNamespaceSpecifier:
+				'Destructure feature flag utils from import. Feature flag usage should be statically analyzable',
+			noReassignment:
+				'Do not reassign feature flag utils. Feature flag usage should be statically analyzable',
+		},
+	},
+	create(context) {
+		return {
+			ImportDeclaration: (node) => {
+				if (typeof node.source.value === 'string' && !IMPORT_SOURCES.has(node.source.value)) {
+					return;
+				}
+
+				node.specifiers?.forEach((specifier) => {
+					if (specifier.type === 'ImportSpecifier') {
+						const { imported, local } = specifier;
+
+						if (imported.name !== local.name) {
+							context.report({
+								messageId: 'noSpecifierAlias',
+								node: specifier,
+							});
+						}
+					} else if (specifier.type === 'ImportNamespaceSpecifier') {
+						context.report({
+							messageId: 'noNamespaceSpecifier',
+							node: specifier,
+						});
+					}
+				});
+			},
+			'VariableDeclaration[kind="const"] > VariableDeclarator[id.type="Identifier"][init.type="Identifier"]':
+				(node: Node<'VariableDeclarator'>) => {
+					if (!node.init || node.init.type !== 'Identifier') {
+						return;
+					}
+
+					const isReassignment = isIdentifierImportedFrom(node.init.name, IMPORT_SOURCES, context);
+
+					if (isReassignment) {
+						context.report({
+							messageId: 'noReassignment',
+							node,
+						});
+					}
+				},
+		};
+	},
+};
+
+export default rule;

package/src/rules/no-duplicate-dependencies/__tests__/unit/rule.test.ts

@@ -2,10 +2,10 @@ import { tester } from '../../../../__tests__/utils/_tester';
 import rule from '../../index';
 
 describe('test no-duplicate-dependencies rule', () => {
-  tester.run('no-duplicate-dependencies-rule', rule, {
-    valid: [
-      {
-        code: `
+	tester.run('no-duplicate-dependencies-rule', rule, {
+		valid: [
+			{
+				code: `
           module.exports = {
             "dependencies": {
               "foo": "^1.0.0",
@@ -13,10 +13,10 @@ describe('test no-duplicate-dependencies rule', () => {
             }
           };
         `,
-        filename: 'dependencies.json',
-      },
-      {
-        code: `
+				filename: 'dependencies.json',
+			},
+			{
+				code: `
           module.exports = {
             "devDependencies": {
               "foo": "^1.0.0",
@@ -24,10 +24,10 @@ describe('test no-duplicate-dependencies rule', () => {
             }
           };
         `,
-        filename: 'devDependencies.json',
-      },
-      {
-        code: `
+				filename: 'devDependencies.json',
+			},
+			{
+				code: `
           module.exports = {
             "dependencies": {
               "foo": "^1.0.0",
@@ -39,12 +39,12 @@ describe('test no-duplicate-dependencies rule', () => {
             }
           };
         `,
-        filename: 'devAndDependencies.json',
-      },
-    ],
-    invalid: [
-      {
-        code: `
+				filename: 'devAndDependencies.json',
+			},
+		],
+		invalid: [
+			{
+				code: `
           module.exports = {
             "dependencies": {
               "foo": "^1.0.0",
@@ -57,7 +57,7 @@ describe('test no-duplicate-dependencies rule', () => {
             }
           };
         `,
-        output: `
+				output: `
           module.exports = {
             "dependencies": {
               "foo": "^1.0.0",
@@ -69,18 +69,18 @@ describe('test no-duplicate-dependencies rule', () => {
             }
           };
         `,
-        errors: [
-          {
-            data: {
-              name: 'foo',
-            },
-            messageId: 'unexpectedDuplicateDependency',
-          },
-        ],
-        filename: 'duplicateDependenciesFirst.json',
-      },
-      {
-        code: `
+				errors: [
+					{
+						data: {
+							name: 'foo',
+						},
+						messageId: 'unexpectedDuplicateDependency',
+					},
+				],
+				filename: 'duplicateDependenciesFirst.json',
+			},
+			{
+				code: `
           module.exports = {
             "dependencies": {
               "bar": "^1.0.0"
@@ -91,7 +91,7 @@ describe('test no-duplicate-dependencies rule', () => {
             }
           };
         `,
-        output: `
+				output: `
           module.exports = {
             "dependencies": {
               "bar": "^1.0.0"
@@ -101,16 +101,16 @@ describe('test no-duplicate-dependencies rule', () => {
             }
           };
         `,
-        errors: [
-          {
-            data: {
-              name: 'bar',
-            },
-            messageId: 'unexpectedDuplicateDependency',
-          },
-        ],
-        filename: 'duplicateDependenciesLast.json',
-      },
-    ],
-  });
+				errors: [
+					{
+						data: {
+							name: 'bar',
+						},
+						messageId: 'unexpectedDuplicateDependency',
+					},
+				],
+				filename: 'duplicateDependenciesLast.json',
+			},
+		],
+	});
 });

package/src/rules/no-duplicate-dependencies/index.ts

@@ -2,83 +2,78 @@
 import type { Rule } from 'eslint';
 
 const rule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'This rule disallows a dependency to be defined in both dependencies and devDependencies',
-      recommended: false,
-    },
-    fixable: 'code',
-    messages: {
-      unexpectedDuplicateDependency: 'Unexpected duplicate dependency {{name}}',
-    },
-  },
-  create(context) {
-    const dependencies = new Map();
-    const devDependencies = new Map();
+	meta: {
+		type: 'problem',
+		docs: {
+			description:
+				'This rule disallows a dependency to be defined in both dependencies and devDependencies',
+			recommended: false,
+		},
+		fixable: 'code',
+		messages: {
+			unexpectedDuplicateDependency: 'Unexpected duplicate dependency {{name}}',
+		},
+	},
+	create(context) {
+		const dependencies = new Map();
+		const devDependencies = new Map();
 
-    return {
-      'ObjectExpression Property[key.value=dependencies] Property': (
-        node: Rule.Node,
-      ) => {
-        // @ts-expect-error
-        dependencies.set(node.key.value, node.key);
-      },
-      'ObjectExpression Property[key.value=devDependencies] Property': (
-        node: Rule.Node,
-      ) => {
-        // @ts-expect-error
-        devDependencies.set(node.key.value, node.key);
-      },
-      'Program:exit': () => {
-        for (const [dependency, node] of devDependencies) {
-          if (dependencies.has(dependency)) {
-            context.report({
-              data: {
-                name: dependency,
-              },
-              fix(fixer) {
-                const sourceCode = context.getSourceCode();
-                const property = node.parent;
-                const isLastLine =
-                  sourceCode.getTokenAfter(property)?.value === '}';
-                const end = property.loc.end;
+		return {
+			'ObjectExpression Property[key.value=dependencies] Property': (node: Rule.Node) => {
+				// @ts-expect-error
+				dependencies.set(node.key.value, node.key);
+			},
+			'ObjectExpression Property[key.value=devDependencies] Property': (node: Rule.Node) => {
+				// @ts-expect-error
+				devDependencies.set(node.key.value, node.key);
+			},
+			'Program:exit': () => {
+				for (const [dependency, node] of devDependencies) {
+					if (dependencies.has(dependency)) {
+						context.report({
+							data: {
+								name: dependency,
+							},
+							fix(fixer) {
+								const sourceCode = context.getSourceCode();
+								const property = node.parent;
+								const isLastLine = sourceCode.getTokenAfter(property)?.value === '}';
+								const end = property.loc.end;
 
-                if (!isLastLine) {
-                  return fixer.removeRange([
-                    sourceCode.getIndexFromLoc({
-                      line: property.loc.start.line,
-                      column: 0,
-                    }),
-                    sourceCode.getIndexFromLoc({
-                      line: end.line + 1,
-                      column: 0,
-                    }),
-                  ]);
-                }
+								if (!isLastLine) {
+									return fixer.removeRange([
+										sourceCode.getIndexFromLoc({
+											line: property.loc.start.line,
+											column: 0,
+										}),
+										sourceCode.getIndexFromLoc({
+											line: end.line + 1,
+											column: 0,
+										}),
+									]);
+								}
 
-                const previousToken = sourceCode.getTokenBefore(property)!;
+								const previousToken = sourceCode.getTokenBefore(property)!;
 
-                return fixer.removeRange([
-                  sourceCode.getIndexFromLoc({
-                    line: previousToken.loc.end.line,
-                    column: previousToken.loc.end.column - 1,
-                  }),
-                  sourceCode.getIndexFromLoc({
-                    line: end.line,
-                    column: end.column,
-                  }),
-                ]);
-              },
-              messageId: 'unexpectedDuplicateDependency',
-              node,
-            });
-          }
-        }
-      },
-    };
-  },
+								return fixer.removeRange([
+									sourceCode.getIndexFromLoc({
+										line: previousToken.loc.end.line,
+										column: previousToken.loc.end.column - 1,
+									}),
+									sourceCode.getIndexFromLoc({
+										line: end.line,
+										column: end.column,
+									}),
+								]);
+							},
+							messageId: 'unexpectedDuplicateDependency',
+							node,
+						});
+					}
+				}
+			},
+		};
+	},
 };
 
 export default rule;

package/src/rules/no-invalid-feature-flag-usage/__tests__/unit/rule.test.tsx

@@ -2,68 +2,68 @@ import { tester } from '../../../../__tests__/utils/_tester';
 import rule from '../../index';
 
 describe('enforce-feature-flag-usage-structure tests', () => {
-  tester.run('ensure-feature-flag-registration', rule, {
-    valid: [
-      {
-        // IfStatement
-        code: `if(getBooleanFF('test-flag')) { }`,
-      },
-      {
-        // negated IfStatement
-        code: `if(!getBooleanFF('test-flag')) { }`,
-      },
-      {
-        // ConditionalExpression
-        code: `const val = getBooleanFF('test-flag') ? 'yay' : 'no';`,
-      },
-      {
-        // LogicalExpression
-        code: `const val = 100 + (getBooleanFF('test-flag') && 50 || 10);`,
-      },
-    ],
-    invalid: [
-      {
-        code: `getBooleanFF('test-flag')`,
-        errors: [{ messageId: 'onlyInlineIf' }],
-      },
-      {
-        code: `const val = getBooleanFF('test-flag')`,
-        errors: [{ messageId: 'onlyInlineIf' }],
-      },
-      {
-        code: `const ff = "test-flag"; if(getBooleanFF(ff)) { }`,
-        errors: [{ messageId: 'onlyStringLiteral' }],
-      },
-      {
-        code: `if(getBooleanFF('test-flag') && getBooleanFF('test-flag')) { }`,
-        errors: [
-          { messageId: 'multipleFlagCheckInExpression' },
-          { messageId: 'multipleFlagCheckInExpression' },
-        ],
-      },
-      {
-        code: `if(!getBooleanFF('test-flag') && !getBooleanFF('test-flag')) { }`,
-        errors: [
-          { messageId: 'multipleFlagCheckInExpression' },
-          { messageId: 'multipleFlagCheckInExpression' },
-        ],
-      },
-      {
-        code: `if((!getBooleanFF('test-flag') || 1 == true) && getBooleanFF('test-flag')) { }`,
-        errors: [
-          { messageId: 'multipleFlagCheckInExpression' },
-          { messageId: 'multipleFlagCheckInExpression' },
-        ],
-      },
-      {
-        code: `export default getBooleanFF('test-flag') ? "this is" : "not good";`,
-        errors: [{ messageId: 'noModuleScope' }],
-      },
-      {
-        only: true,
-        code: `export const foo = getBooleanFF('test-flag') ? "this is" : "not good";`,
-        errors: [{ messageId: 'noModuleScope' }],
-      },
-    ],
-  });
+	tester.run('ensure-feature-flag-registration', rule, {
+		valid: [
+			{
+				// IfStatement
+				code: `if(getBooleanFF('test-flag')) { }`,
+			},
+			{
+				// negated IfStatement
+				code: `if(!getBooleanFF('test-flag')) { }`,
+			},
+			{
+				// ConditionalExpression
+				code: `const val = getBooleanFF('test-flag') ? 'yay' : 'no';`,
+			},
+			{
+				// LogicalExpression
+				code: `const val = 100 + (getBooleanFF('test-flag') && 50 || 10);`,
+			},
+		],
+		invalid: [
+			{
+				code: `getBooleanFF('test-flag')`,
+				errors: [{ messageId: 'onlyInlineIf' }],
+			},
+			{
+				code: `const val = getBooleanFF('test-flag')`,
+				errors: [{ messageId: 'onlyInlineIf' }],
+			},
+			{
+				code: `const ff = "test-flag"; if(getBooleanFF(ff)) { }`,
+				errors: [{ messageId: 'onlyStringLiteral' }],
+			},
+			{
+				code: `if(getBooleanFF('test-flag') && getBooleanFF('test-flag')) { }`,
+				errors: [
+					{ messageId: 'multipleFlagCheckInExpression' },
+					{ messageId: 'multipleFlagCheckInExpression' },
+				],
+			},
+			{
+				code: `if(!getBooleanFF('test-flag') && !getBooleanFF('test-flag')) { }`,
+				errors: [
+					{ messageId: 'multipleFlagCheckInExpression' },
+					{ messageId: 'multipleFlagCheckInExpression' },
+				],
+			},
+			{
+				code: `if((!getBooleanFF('test-flag') || 1 == true) && getBooleanFF('test-flag')) { }`,
+				errors: [
+					{ messageId: 'multipleFlagCheckInExpression' },
+					{ messageId: 'multipleFlagCheckInExpression' },
+				],
+			},
+			{
+				code: `export default getBooleanFF('test-flag') ? "this is" : "not good";`,
+				errors: [{ messageId: 'noModuleScope' }],
+			},
+			{
+				only: true,
+				code: `export const foo = getBooleanFF('test-flag') ? "this is" : "not good";`,
+				errors: [{ messageId: 'noModuleScope' }],
+			},
+		],
+	});
 });