@atlaskit/eslint-plugin-platform 2.7.0 → 2.7.1

package/src/rules/ensure-atlassian-team/__tests__/unit/rule.test.ts

@@ -1,24 +0,0 @@
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../../index';
-
-describe('test no-pre-post-installs rule', () => {
-	tester.run('no-pre-post-installs', rule, {
-		valid: [
-			{
-				code: `const foo = {}`,
-				filename: 'package.json',
-			},
-			{
-				code: `const foo = { "atlassian": { "team": "bar" } }`,
-				filename: 'foo/package.json',
-			},
-		],
-		invalid: [
-			{
-				code: `const foo = { "atlassian": {} }`,
-				filename: 'foo/package.json',
-				errors: [{ messageId: 'atlassianTeamRequired' }],
-			},
-		],
-	});
-});

package/src/rules/ensure-atlassian-team/index.ts

@@ -1,51 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import type { Rule } from 'eslint';
-
-const rule: Rule.RuleModule = {
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'This rule ensures that the internal packages have a responsible team attached.',
-			recommended: true,
-		},
-		hasSuggestions: false,
-		messages: {
-			atlassianTeamRequired: 'The atlassian.team property is required',
-		},
-	},
-	create(context) {
-		return {
-			ObjectExpression: (node: Rule.Node) => {
-				if (!context.getFilename().endsWith('package.json') || node.type !== 'ObjectExpression') {
-					return;
-				}
-
-				const atlassianProp = node.properties.find(
-					(p) => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'atlassian',
-				);
-
-				if (!atlassianProp) {
-					return;
-				}
-
-				if (atlassianProp.type !== 'Property' || atlassianProp.value.type !== 'ObjectExpression') {
-					return;
-				}
-
-				const teamProp = atlassianProp.value.properties.find(
-					(p) => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'team',
-				);
-
-				// this just checks for existence, we can potentially cross-reference it with teams.json to make sure its valid in the future.
-				if (!teamProp) {
-					return context.report({
-						node,
-						messageId: 'atlassianTeamRequired',
-					});
-				}
-			},
-		};
-	},
-};
-
-export default rule;

package/src/rules/ensure-critical-dependency-resolutions/__test__/unit/rule.test.tsx

@@ -1,200 +0,0 @@
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../../index';
-
-const cwd = process.cwd();
-
-describe('test ensure-critical-dependency-resolutions rule', () => {
-	tester.run('ensure-critical-dependency-resolutions', rule, {
-		valid: [
-			// Root package.json, have all of the correct resolutions
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "16.14.15",
-                "typescript": "5.4.2",
-				"tslib": "2.6.3",
-                "react-relay": "npm:atl-react-relay@0.0.0-main-5980a913",
-                "relay-compiler": "npm:atl-relay-compiler@0.0.0-main-5980a913",
-                "relay-runtime": "npm:atl-relay-runtime@0.0.0-main-5980a913",
-                "relay-test-utils": "npm:atl-relay-test-utils@0.0.0-main-5980a913",
-            }
-        }`,
-				filename: `${cwd}/package.json`,
-			},
-			// Root package.json, have all of the correct resolutions
-			{
-				code: `const foo = {
-                  "resolutions": {
-                      "@types/react": "18.2.28",
-                      "typescript": "5.4.2",
-					  "tslib": "2.6.3",
-                      "react-relay": "npm:atl-react-relay@0.0.0-main-5980a913",
-                      "relay-compiler": "npm:atl-relay-compiler@0.0.0-main-5980a913",
-                      "relay-runtime": "npm:atl-relay-runtime@0.0.0-main-5980a913",
-                      "relay-test-utils": "npm:atl-relay-test-utils@0.0.0-main-5980a913",
-                  }
-              }`,
-				filename: `${cwd}/package.json`,
-			},
-			// Root package.json, have all of the correct resolutions with ~
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "~16.14.25",
-                "typescript": "~5.4.2",
-                "tslib": "~2.6.3",
-                "react-relay": "npm:atl-react-relay@0.0.0-main-5980a913",
-                "relay-compiler": "npm:atl-relay-compiler@0.0.0-main-5980a913",
-                "relay-runtime": "npm:atl-relay-runtime@0.0.0-main-5980a913",
-                "relay-test-utils": "npm:atl-relay-test-utils@0.0.0-main-5980a913",
-            }
-        }`,
-				filename: `${cwd}/package.json`,
-			},
-			// Root package.json, have some of the correct resolutions
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "~16.14.25",
-                "typescript": "~5.4.2",
-                "tslib": "~2.6.3",
-            }
-        }`,
-				filename: `${cwd}/package.json`,
-			},
-			// Root package.json, have some of the correct resolutions
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "~16.14.25",
-                "typescript": "~5.4.2",
-                "react-relay": "npm:atl-react-relay@0.0.0-main-5980a913",
-            },
-            "dependencies": {
-                "@types/react": "~16.14.25",
-                "typescript": "~5.4.2",
-                "react-relay": "npm:atl-react-relay@0.0.0-main-5980a913",
-            }
-        }`,
-				filename: `${cwd}/package.json`,
-			},
-			// Individual package's package.json. Have part of correct resolutions
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "16.14.15",
-            }
-        }`,
-				filename: `${cwd}/package/name/package.json`,
-			},
-			// Individual package's package.json. Not have relevant package resolutions
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/abcd": "1.2.3",
-            }
-        }`,
-				filename: `${cwd}/package/name/package.json`,
-			},
-		],
-		invalid: [
-			// Root package.json. One package is correct, the other is missing
-			{
-				code: `const foo = {
-                "resolutions": {
-                    "typescript": "~5.4.2",
-                },
-
-                "dependencies": {
-                    "@types/react": "~16.14.25",
-                    "typescript": "~5.4.2",
-                }
-            }`,
-				filename: `${cwd}/package.json`,
-				errors: [
-					{
-						messageId: 'invalidPackageResolution',
-					},
-				],
-			},
-			// Root package.json. Resolutions are missing but package is present in dependencies
-			{
-				code: `const foo = {
-                "resolutions": {
-                },
-
-                "dependencies": {
-                    "@types/react": "~16.14.25",
-                    "typescript": "~5.4.2",
-                }
-            }`,
-				filename: `${cwd}/package.json`,
-				errors: [
-					{
-						messageId: 'invalidPackageResolution',
-					},
-				],
-			},
-			// Root package.json. Both packages have the wrong version ranges
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "16.8.25",
-                "typescript": "5.1.1",
-            }
-        }`,
-				filename: `${cwd}/package.json`,
-				errors: [
-					{
-						messageId: 'invalidPackageResolution',
-					},
-				],
-			},
-			// Root package.json. One package is correct, the other has wrong version range
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "~16.14.25",
-                "typescript": "~5.1.1",
-            }
-        }`,
-				filename: `${cwd}/package.json`,
-				errors: [
-					{
-						messageId: 'invalidPackageResolution',
-					},
-				],
-			},
-			// Root package.json. One package is correct, the other has ^ in its version
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "~16.14.25",
-                "typescript": "^5.4.2",
-            }
-        }`,
-				filename: `${cwd}/package.json`,
-				errors: [
-					{
-						messageId: 'invalidPackageResolution',
-					},
-				],
-			},
-			// Individual package's package.json. One package is correct, the other is wrong
-			{
-				code: `const foo = {
-            "resolutions": {
-                "@types/react": "16.14.15",
-                "typescript": "5.1.1",
-            }
-        }`,
-				filename: `${cwd}/packages/packge/directory/package.json`,
-				errors: [
-					{
-						messageId: 'invalidPackageResolution',
-					},
-				],
-			},
-		],
-	});
-});

package/src/rules/ensure-critical-dependency-resolutions/index.tsx

@@ -1,172 +0,0 @@
-import { findRootSync } from '@manypkg/find-root';
-// eslint-disable-next-line import/no-extraneous-dependencies
-import type { Rule } from 'eslint';
-import type { ObjectExpression } from 'estree';
-import { getObjectPropertyAsObject } from '../util/handle-ast-object';
-
-// Here we only need to specify the major and minor versions
-// In matchMinorVersion, we will check if the versions in resolutions fall in the right ranges.
-//
-const DESIRED_PKG_VERSIONS: Record<string, string[]> = {
-	typescript: ['5.4'],
-	tslib: ['2.6'],
-	'@types/react': ['16.14', '18.2'],
-	'react-relay': ['npm:atl-react-relay@0.0.0-main-5980a913'],
-	'relay-compiler': ['npm:atl-relay-compiler@0.0.0-main-5980a913'],
-	'relay-runtime': ['npm:atl-relay-runtime@0.0.0-main-5980a913'],
-	'relay-test-utils': ['npm:atl-relay-test-utils@0.0.0-main-5980a913'],
-};
-
-const matchMinorVersion = (desiredVersion: string, versionInResolutions: string): boolean => {
-	const firstChar = versionInResolutions[0];
-	// The version is invalid if it doesn't start with a number or ~
-	if (!/^\d$/.test(firstChar) && firstChar !== '~' && !versionInResolutions.startsWith('npm:')) {
-		return false;
-	}
-
-	return (
-		versionInResolutions.startsWith(desiredVersion) ||
-		versionInResolutions.startsWith('~' + desiredVersion)
-	);
-};
-
-const verifyResolutionFromObject = ({
-	resolutions,
-	dependencies,
-	devDependencies,
-	pkg,
-	version,
-	optional,
-}: {
-	resolutions: ObjectExpression;
-	dependencies: ObjectExpression | null;
-	devDependencies: ObjectExpression | null;
-	pkg: string;
-	version: string;
-	optional: boolean;
-}): boolean => {
-	// For root package.json, we require the critical packages' resolutions exist and with matching version
-	// For individual package's package.json, it's ok if resolutions don't exist. But if they do, the version should match
-	const resolutionExist = resolutions.properties.some(
-		(p) => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg,
-	);
-
-	isDependencyPresent({
-		resolutions,
-		dependencies,
-		devDependencies,
-		pkg,
-	});
-
-	if (!resolutionExist) {
-		// when package is not a part of dependencies/devDependencies
-		if (
-			optional === false &&
-			!isDependencyPresent({
-				resolutions,
-				dependencies,
-				devDependencies,
-				pkg,
-			})
-		) {
-			return true;
-		}
-
-		return optional;
-	}
-
-	const resolutionExistAndMatch = resolutions.properties.some(
-		(p) =>
-			p.type === 'Property' &&
-			p.key.type === 'Literal' &&
-			p.key.value === pkg &&
-			p.value.type === 'Literal' &&
-			matchMinorVersion(version, p.value.value as string),
-	);
-
-	return resolutionExistAndMatch;
-};
-
-type IsDependencyPresentProps = {
-	resolutions: ObjectExpression | null;
-	dependencies: ObjectExpression | null;
-	devDependencies: ObjectExpression | null;
-	pkg: string;
-};
-const isDependencyPresent = ({
-	resolutions,
-	dependencies,
-	devDependencies,
-	pkg,
-}: IsDependencyPresentProps) => {
-	const dependencyExist =
-		dependencies !== null &&
-		dependencies.properties.some(
-			(p) => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg,
-		);
-
-	const devDependencyExist =
-		devDependencies !== null &&
-		devDependencies.properties.some(
-			(p) => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg,
-		);
-
-	return dependencyExist || devDependencyExist;
-};
-
-const rule: Rule.RuleModule = {
-	meta: {
-		type: 'problem',
-		docs: {
-			description:
-				'Enforce the versions of critical packages are within desired ranges by checking resolutions section in package.json',
-			recommended: true,
-		},
-		hasSuggestions: false,
-		messages: {
-			invalidPackageResolution: `Make sure the resolutions for the following packages match major and minor version ranges ${JSON.stringify(
-				DESIRED_PKG_VERSIONS,
-			)}`,
-		},
-	},
-	create(context) {
-		const fileName = context.getFilename();
-		return {
-			ObjectExpression: (node: Rule.Node) => {
-				if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
-					return;
-				}
-
-				const packageResolutions = getObjectPropertyAsObject(node, 'resolutions');
-				const packageDependencies = getObjectPropertyAsObject(node, 'dependencies');
-				const packageDevDependencies = getObjectPropertyAsObject(node, 'devDependencies');
-				const rootDir = findRootSync(process.cwd());
-				const isRootPackageJson = fileName.endsWith(`${rootDir}/package.json`);
-
-				if (packageResolutions !== null) {
-					for (const [key, values] of Object.entries(DESIRED_PKG_VERSIONS)) {
-						if (
-							!values.some((value) => {
-								return verifyResolutionFromObject({
-									resolutions: packageResolutions as ObjectExpression,
-									dependencies: packageDependencies,
-									devDependencies: packageDevDependencies,
-									pkg: key,
-									version: value,
-									optional: !isRootPackageJson,
-								});
-							})
-						) {
-							return context.report({
-								node,
-								messageId: 'invalidPackageResolution',
-							});
-						}
-					}
-				}
-			},
-		};
-	},
-};
-
-export default rule;

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

@@ -1,65 +0,0 @@
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../../index';
-import { type PackageJson } from 'read-pkg-up';
-
-let mockPath = 'test/package.json';
-
-let mockPackageJson: PackageJson = {
-	'platform-feature-flags': {
-		'test-flag': {
-			type: 'boolean',
-		},
-	},
-};
-jest.mock('read-pkg-up', () => ({
-	sync: () => ({
-		path: mockPath,
-		packageJson: mockPackageJson,
-	}),
-}));
-
-describe('test prefix rule', () => {
-	beforeEach(() => {
-		mockPath = 'test/package.json';
-
-		mockPackageJson = {
-			'platform-feature-flags': {
-				'prefix-flag': {
-					type: 'boolean',
-				},
-				'no-prefix-flag': {
-					type: 'boolean',
-				},
-			},
-		};
-	});
-
-	// this isolates the invalid case so we can test the suggestion properly
-	tester.run('ensure-feature-flag-registration', rule, {
-		valid: [
-			{
-				options: [{ allowedPrefixes: ['prefix'] }],
-				code: `ffTest('prefix-flag')`,
-			},
-			{
-				options: [{ allowedPrefixes: ['prefix'] }],
-				code: `getBooleanFF('prefix-flag')`,
-			},
-		],
-		invalid: [
-			{
-				options: [{ allowedPrefixes: ['prefix'] }],
-				code: `ffTest('no-prefix-flag')`,
-				errors: [
-					{
-						messageId: 'featureFlagIncorrectPrefix',
-						data: {
-							featureFlag: 'no-prefix-flag',
-							allowedPrefixes: 'prefix',
-						},
-					},
-				],
-			},
-		],
-	});
-});

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

@@ -1,81 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import type { Rule } from 'eslint';
-import { getMetadataForFilename, getterIdentifierToFlagTypeMap } from '../util/registration-utils';
-
-type RuleOptions = {
-	allowedPrefixes: string[];
-};
-
-const rule: Rule.RuleModule = {
-	meta: {
-		docs: {
-			url: 'http://go/pff-eslint',
-			recommended: false,
-		},
-		type: 'problem',
-		messages: {
-			featureFlagIncorrectPrefix: `Is this a LaunchDarkly feature flag? It needs a prefix so Confluence picks it up: [{{ allowedPrefixes }}]. Statsig feature gates don't need a prefix.`,
-		},
-		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;
-
-						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 {};
-						}
-
-						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 {};
-				},
-			]),
-		);
-	},
-};
-
-export default rule;

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

@@ -1,115 +0,0 @@
-import { tester } from '../../../../__tests__/utils/_tester';
-import rule from '../../index';
-import { type PackageJson } from 'read-pkg-up';
-
-let mockPath = 'test/package.json';
-
-let mockPackageJson: PackageJson = {
-	'platform-feature-flags': {
-		'test-flag': {
-			type: 'boolean',
-		},
-	},
-};
-jest.mock('read-pkg-up', () => ({
-	sync: () => ({
-		path: mockPath,
-		packageJson: mockPackageJson,
-	}),
-}));
-
-describe('with existing platform-feature-flags section', () => {
-	beforeEach(() => {
-		mockPath = 'test/package.json';
-
-		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',
-						},
-					},
-				],
-			},
-		],
-	});
-});
-
-describe('with missing platform-feature-flags section', () => {
-	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' }],
-			},
-		],
-	});
-});