@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

package/src/rules/ensure-feature-flag-prefix/index.tsx

@@ -1,95 +1,80 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import type { Rule } from 'eslint';
-import {
-  getMetadataForFilename,
-  getterIdentifierToFlagTypeMap,
-} from '../util/registration-utils';
+import { getMetadataForFilename, getterIdentifierToFlagTypeMap } from '../util/registration-utils';
 
 type RuleOptions = {
-  allowedPrefixes: string[];
+	allowedPrefixes: string[];
 };
 
 const rule: Rule.RuleModule = {
-  meta: {
-    docs: {
-      recommended: false,
-    },
-    type: 'problem',
-    messages: {
-      featureFlagIncorrectPrefix: `Please change your flag "{{ featureFlag }}" to have a valid prefix, options are [{{ allowedPrefixes }}]. See http://go/pff-eslint for details`,
-    },
-    hasSuggestions: true,
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          allowedPrefixes: {
-            type: 'array',
-            items: [
-              {
-                type: 'string',
-              },
-            ],
-          },
-        },
-        required: ['allowedPrefixes'],
-      },
-    ],
-  },
-  create(context) {
-    const { allowedPrefixes } = (context.options?.[0] as RuleOptions) ?? {};
+	meta: {
+		docs: {
+			recommended: false,
+		},
+		type: 'problem',
+		messages: {
+			featureFlagIncorrectPrefix: `Please change your flag "{{ featureFlag }}" to have a valid prefix, options are [{{ allowedPrefixes }}]. See http://go/pff-eslint for details`,
+		},
+		hasSuggestions: true,
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					allowedPrefixes: {
+						type: 'array',
+						items: [
+							{
+								type: 'string',
+							},
+						],
+					},
+				},
+				required: ['allowedPrefixes'],
+			},
+		],
+	},
+	create(context) {
+		const { allowedPrefixes } = (context.options?.[0] as RuleOptions) ?? {};
 
-    return Object.fromEntries(
-      (
-        Object.keys(
-          getterIdentifierToFlagTypeMap,
-        ) as (keyof typeof getterIdentifierToFlagTypeMap)[]
-      ).map((getterIdentifier) => [
-        `CallExpression[callee.name=/${getterIdentifier}/]`,
-        (node: Rule.Node) => {
-          // to make typescript happy
-          if (node.type === 'CallExpression') {
-            const args = node.arguments;
+		return Object.fromEntries(
+			(
+				Object.keys(getterIdentifierToFlagTypeMap) as (keyof typeof getterIdentifierToFlagTypeMap)[]
+			).map((getterIdentifier) => [
+				`CallExpression[callee.name=/${getterIdentifier}/]`,
+				(node: Rule.Node) => {
+					// to make typescript happy
+					if (node.type === 'CallExpression') {
+						const args = node.arguments;
 
-            const filename = context.getFilename();
-            const { pkgJson: packageJson } = getMetadataForFilename(filename);
-            const platformFeatureFlags = packageJson['platform-feature-flags'];
+						const filename = context.getFilename();
+						const { pkgJson: packageJson } = getMetadataForFilename(filename);
+						const platformFeatureFlags = packageJson['platform-feature-flags'];
 
-            // existence of registration section is done in 'ensure-feature-flag-registration'
-            if (!platformFeatureFlags) {
-              return {};
-            }
+						// existence of registration section is done in 'ensure-feature-flag-registration'
+						if (!platformFeatureFlags) {
+							return {};
+						}
 
-            if (
-              args.length === 1 &&
-              args[0].type === 'Literal' &&
-              args[0].raw
-            ) {
-              const featureFlag = args[0].value as string;
-              if (
-                !allowedPrefixes.some((prefix) =>
-                  featureFlag.startsWith(prefix),
-                )
-              ) {
-                return context.report({
-                  node: args[0],
-                  messageId: 'featureFlagIncorrectPrefix',
-                  data: {
-                    allowedPrefixes: allowedPrefixes
-                      .map((p) => `${p}`)
-                      .join(','),
-                    featureFlag,
-                  },
-                });
-              }
-            }
-          }
+						if (args.length === 1 && args[0].type === 'Literal' && args[0].raw) {
+							const featureFlag = args[0].value as string;
+							if (!allowedPrefixes.some((prefix) => featureFlag.startsWith(prefix))) {
+								return context.report({
+									node: args[0],
+									messageId: 'featureFlagIncorrectPrefix',
+									data: {
+										allowedPrefixes: allowedPrefixes.map((p) => `${p}`).join(','),
+										featureFlag,
+									},
+								});
+							}
+						}
+					}
 
-          return {};
-        },
-      ]),
-    );
-  },
+					return {};
+				},
+			]),
+		);
+	},
 };
 
 export default rule;

package/src/rules/ensure-feature-flag-registration/__tests__/unit/rule.test.tsx

@@ -1,115 +1,115 @@
 import { tester } from '../../../../__tests__/utils/_tester';
 import rule from '../../index';
-import { PackageJson } from 'read-pkg-up';
+import { type PackageJson } from 'read-pkg-up';
 
 let mockPath = 'test/package.json';
 
 let mockPackageJson: PackageJson = {
-  'platform-feature-flags': {
-    'test-flag': {
-      type: 'boolean',
-    },
-  },
+	'platform-feature-flags': {
+		'test-flag': {
+			type: 'boolean',
+		},
+	},
 };
 jest.mock('read-pkg-up', () => ({
-  sync: () => ({
-    path: mockPath,
-    packageJson: mockPackageJson,
-  }),
+	sync: () => ({
+		path: mockPath,
+		packageJson: mockPackageJson,
+	}),
 }));
 
 describe('with existing platform-feature-flags section', () => {
-  beforeEach(() => {
-    mockPath = 'test/package.json';
+	beforeEach(() => {
+		mockPath = 'test/package.json';
 
-    mockPackageJson = {
-      'platform-feature-flags': {
-        'test-flag': {
-          type: 'boolean',
-        },
-        'string-flag': {
-          type: 'string',
-        },
-      },
-    };
-  });
+		mockPackageJson = {
+			'platform-feature-flags': {
+				'test-flag': {
+					type: 'boolean',
+				},
+				'string-flag': {
+					type: 'string',
+				},
+			},
+		};
+	});
 
-  // this isolates the invalid case so we can test the suggestion properly
-  tester.run('ensure-feature-flag-registration', rule, {
-    valid: [
-      {
-        code: `getBooleanFF('test-flag')`,
-      },
-      {
-        code: `ffTest('test-flag')`,
-      },
-    ],
-    invalid: [
-      {
-        code: `ffTest('test-flag-invalid')`,
-        errors: [
-          {
-            messageId: 'featureFlagMissing',
-            suggestions: [
-              {
-                messageId: 'changeFeatureFlag',
-                data: {
-                  closestFlag: 'test-flag',
-                },
-                output: `ffTest('test-flag')`,
-              },
-            ],
-          },
-        ],
-      },
-      {
-        code: `getBooleanFF('test-flag-invalid')`,
-        errors: [
-          {
-            messageId: 'featureFlagMissing',
-            suggestions: [
-              {
-                messageId: 'changeFeatureFlag',
-                data: {
-                  closestFlag: 'test-flag',
-                },
-                output: `getBooleanFF('test-flag')`,
-              },
-            ],
-          },
-        ],
-      },
-      {
-        code: `getBooleanFF('string-flag')`,
-        errors: [
-          {
-            messageId: 'featureFlagIncorrectType',
-            data: {
-              featureFlag: 'string-flag',
-              expectedType: 'boolean',
-            },
-          },
-        ],
-      },
-    ],
-  });
+	// this isolates the invalid case so we can test the suggestion properly
+	tester.run('ensure-feature-flag-registration', rule, {
+		valid: [
+			{
+				code: `getBooleanFF('test-flag')`,
+			},
+			{
+				code: `ffTest('test-flag')`,
+			},
+		],
+		invalid: [
+			{
+				code: `ffTest('test-flag-invalid')`,
+				errors: [
+					{
+						messageId: 'featureFlagMissing',
+						suggestions: [
+							{
+								messageId: 'changeFeatureFlag',
+								data: {
+									closestFlag: 'test-flag',
+								},
+								output: `ffTest('test-flag')`,
+							},
+						],
+					},
+				],
+			},
+			{
+				code: `getBooleanFF('test-flag-invalid')`,
+				errors: [
+					{
+						messageId: 'featureFlagMissing',
+						suggestions: [
+							{
+								messageId: 'changeFeatureFlag',
+								data: {
+									closestFlag: 'test-flag',
+								},
+								output: `getBooleanFF('test-flag')`,
+							},
+						],
+					},
+				],
+			},
+			{
+				code: `getBooleanFF('string-flag')`,
+				errors: [
+					{
+						messageId: 'featureFlagIncorrectType',
+						data: {
+							featureFlag: 'string-flag',
+							expectedType: 'boolean',
+						},
+					},
+				],
+			},
+		],
+	});
 });
 
 describe('with missing platform-feature-flags section', () => {
-  beforeEach(() => {
-    // change path to bust cache
-    mockPath = 'invalid-pkg/package.json';
-    mockPackageJson = {};
-  });
+	beforeEach(() => {
+		// change path to bust cache
+		mockPath = 'invalid-pkg/package.json';
+		mockPackageJson = {};
+	});
 
-  tester.run('ensure-feature-flag-registration', rule, {
-    valid: [],
-    invalid: [
-      {
-        filename: 'other-directory/index.ts',
-        code: `if(getBooleanFF('test-flag')) { }`,
-        errors: [{ messageId: 'registrationSectionMissing' }],
-      },
-    ],
-  });
+	tester.run('ensure-feature-flag-registration', rule, {
+		valid: [],
+		invalid: [
+			{
+				filename: 'other-directory/index.ts',
+				code: `if(getBooleanFF('test-flag')) { }`,
+				errors: [{ messageId: 'registrationSectionMissing' }],
+			},
+		],
+	});
 });

package/src/rules/ensure-feature-flag-registration/index.tsx

@@ -1,123 +1,106 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import type { Rule } from 'eslint';
-import {
-  getMetadataForFilename,
-  getterIdentifierToFlagTypeMap,
-} from '../util/registration-utils';
+import { getMetadataForFilename, getterIdentifierToFlagTypeMap } from '../util/registration-utils';
 
 const rule: Rule.RuleModule = {
-  meta: {
-    docs: {
-      recommended: false,
-    },
-    type: 'problem',
-    messages: {
-      registrationSectionMissing:
-        'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
-      featureFlagMissing: `Please add a "{{ featureFlag }}" section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details`,
-      changeFeatureFlag: `Change flag key to "{{ closestFlag }}" already defined in package.json`,
-      featureFlagIncorrectType: `Please change the type for "{{ featureFlag }}" to "{{ expectedType }}" in the section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details"`,
-    },
+	meta: {
+		docs: {
+			recommended: false,
+		},
+		type: 'problem',
+		messages: {
+			registrationSectionMissing:
+				'Please add a "platform-feature-flags" section to your package.json! See http://go/pff-eslint for more details',
+			featureFlagMissing: `Please add a "{{ featureFlag }}" section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details`,
+			changeFeatureFlag: `Change flag key to "{{ closestFlag }}" already defined in package.json`,
+			featureFlagIncorrectType: `Please change the type for "{{ featureFlag }}" to "{{ expectedType }}" in the section to the "platform-feature-flags" section in your package.json. See http://go/pff-eslint for more details"`,
+		},
 
-    hasSuggestions: true,
-  },
-  create(context) {
-    return Object.fromEntries(
-      (
-        Object.keys(
-          getterIdentifierToFlagTypeMap,
-        ) as (keyof typeof getterIdentifierToFlagTypeMap)[]
-      ).map((getterIdentifier) => [
-        `CallExpression[callee.name=/${getterIdentifier}/]`,
-        (node: Rule.Node) => {
-          // to make typescript happy
-          if (node.type === 'CallExpression') {
-            const args = node.arguments;
+		hasSuggestions: true,
+	},
+	create(context) {
+		return Object.fromEntries(
+			(
+				Object.keys(getterIdentifierToFlagTypeMap) as (keyof typeof getterIdentifierToFlagTypeMap)[]
+			).map((getterIdentifier) => [
+				`CallExpression[callee.name=/${getterIdentifier}/]`,
+				(node: Rule.Node) => {
+					// to make typescript happy
+					if (node.type === 'CallExpression') {
+						const args = node.arguments;
 
-            const filename = context.getFilename();
-            const { pkgJson: packageJson, fuse } =
-              getMetadataForFilename(filename);
-            const platformFeatureFlags = packageJson['platform-feature-flags'];
+						const filename = context.getFilename();
+						const { pkgJson: packageJson, fuse } = getMetadataForFilename(filename);
+						const platformFeatureFlags = packageJson['platform-feature-flags'];
 
-            if (!platformFeatureFlags) {
-              return context.report({
-                node: node,
-                messageId: 'registrationSectionMissing',
-              });
-            }
+						if (!platformFeatureFlags) {
+							return context.report({
+								node: node,
+								messageId: 'registrationSectionMissing',
+							});
+						}
 
-            if (
-              args.length === 1 &&
-              args[0].type === 'Literal' &&
-              args[0].raw
-            ) {
-              const featureFlag = args[0].value as string;
-              const featureFlagRegistration = platformFeatureFlags[featureFlag];
+						if (args.length === 1 && args[0].type === 'Literal' && args[0].raw) {
+							const featureFlag = args[0].value as string;
+							const featureFlagRegistration = platformFeatureFlags[featureFlag];
 
-              const expectedType =
-                getterIdentifierToFlagTypeMap[getterIdentifier];
+							const expectedType = getterIdentifierToFlagTypeMap[getterIdentifier];
 
-              // ensure the flag type matches what is registered
-              if (
-                featureFlagRegistration != null &&
-                expectedType != null &&
-                featureFlagRegistration?.type !== expectedType
-              ) {
-                return context.report({
-                  node: args[0],
-                  messageId: 'featureFlagIncorrectType',
-                  data: {
-                    featureFlag,
-                    expectedType,
-                  },
-                });
-              }
+							// ensure the flag type matches what is registered
+							if (
+								featureFlagRegistration != null &&
+								expectedType != null &&
+								featureFlagRegistration?.type !== expectedType
+							) {
+								return context.report({
+									node: args[0],
+									messageId: 'featureFlagIncorrectType',
+									data: {
+										featureFlag,
+										expectedType,
+									},
+								});
+							}
 
-              if (!featureFlagRegistration) {
-                // find the closest match in existing section for suggestion text
-                let closestMatchFix: Rule.SuggestionReportDescriptor | null =
-                  null;
+							if (!featureFlagRegistration) {
+								// find the closest match in existing section for suggestion text
+								let closestMatchFix: Rule.SuggestionReportDescriptor | null = null;
 
-                if (fuse) {
-                  const closestFlagMatches = fuse.search(featureFlag);
-                  if (closestFlagMatches.length > 0) {
-                    const closestFlag = closestFlagMatches[0].item;
+								if (fuse) {
+									const closestFlagMatches = fuse.search(featureFlag);
+									if (closestFlagMatches.length > 0) {
+										const closestFlag = closestFlagMatches[0].item;
 
-                    closestMatchFix = {
-                      messageId: 'changeFeatureFlag',
-                      data: {
-                        closestFlag,
-                      },
-                      fix: (fixer) => {
-                        return fixer.replaceText(
-                          node.arguments[0],
-                          `'${closestFlag}'`,
-                        );
-                      },
-                    };
-                  }
-                }
+										closestMatchFix = {
+											messageId: 'changeFeatureFlag',
+											data: {
+												closestFlag,
+											},
+											fix: (fixer) => {
+												return fixer.replaceText(node.arguments[0], `'${closestFlag}'`);
+											},
+										};
+									}
+								}
 
-                return context.report({
-                  node: args[0],
-                  messageId: 'featureFlagMissing',
-                  data: {
-                    featureFlag,
-                  },
-                  // only suggest if we have a close flag to match
-                  ...(closestMatchFix != null
-                    ? { suggest: [closestMatchFix] }
-                    : {}),
-                });
-              }
-            }
-          }
+								return context.report({
+									node: args[0],
+									messageId: 'featureFlagMissing',
+									data: {
+										featureFlag,
+									},
+									// only suggest if we have a close flag to match
+									...(closestMatchFix != null ? { suggest: [closestMatchFix] } : {}),
+								});
+							}
+						}
+					}
 
-          return {};
-        },
-      ]),
-    );
-  },
+					return {};
+				},
+			]),
+		);
+	},
 };
 
 export default rule;