@atlaskit/eslint-plugin-platform 0.6.1 → 0.7.0

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

@@ -4,132 +4,197 @@ 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 = {
+	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-2ccd6998",
+                "relay-compiler": "npm:atl-relay-compiler@0.0.0-main-2ccd6998",
+                "relay-runtime": "npm:atl-relay-runtime@0.0.0-main-2ccd6998",
+                "relay-test-utils": "npm:atl-relay-test-utils@0.0.0-main-2ccd6998",
             }
         }`,
-        filename: `${cwd}/package.json`,
-      },
-      // Root package.json, have all of the correct resolutions
-      {
-        code: `const foo = {
+				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-2ccd6998",
+                      "relay-compiler": "npm:atl-relay-compiler@0.0.0-main-2ccd6998",
+                      "relay-runtime": "npm:atl-relay-runtime@0.0.0-main-2ccd6998",
+                      "relay-test-utils": "npm:atl-relay-test-utils@0.0.0-main-2ccd6998",
                   }
               }`,
-        filename: `${cwd}/package.json`,
-      },
-      // Root package.json, have all of the correct resolutions with ~
-      {
-        code: `const foo = {
+				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-2ccd6998",
+                "relay-compiler": "npm:atl-relay-compiler@0.0.0-main-2ccd6998",
+                "relay-runtime": "npm:atl-relay-runtime@0.0.0-main-2ccd6998",
+                "relay-test-utils": "npm:atl-relay-test-utils@0.0.0-main-2ccd6998",
             }
         }`,
-        filename: `${cwd}/package.json`,
-      },
-      // Individual package's package.json. Have part of correct resolutions
-      {
-        code: `const foo = {
+				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-2ccd6998",
+            },
+            "dependencies": {
+                "@types/react": "~16.14.25",
+                "typescript": "~5.4.2",
+                "react-relay": "npm:atl-react-relay@0.0.0-main-2ccd6998",
+            }
+        }`,
+				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 = {
+				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 = {
+				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 = {
+				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 = {
+				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 = {
+				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 = {
+				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',
-          },
-        ],
-      },
-    ],
-  });
+				filename: `${cwd}/packages/packge/directory/package.json`,
+				errors: [
+					{
+						messageId: 'invalidPackageResolution',
+					},
+				],
+			},
+		],
+	});
 });

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

@@ -8,110 +8,165 @@ import { getObjectPropertyAsObject } from '../util/handle-ast-object';
 // 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'],
-  '@types/react': ['16.14', '18.2'],
+	typescript: ['5.4'],
+	tslib: ['2.6'],
+	'@types/react': ['16.14', '18.2'],
+	'react-relay': ['npm:atl-react-relay@0.0.0-main-2ccd6998'],
+	'relay-compiler': ['npm:atl-relay-compiler@0.0.0-main-2ccd6998'],
+	'relay-runtime': ['npm:atl-relay-runtime@0.0.0-main-2ccd6998'],
+	'relay-test-utils': ['npm:atl-relay-test-utils@0.0.0-main-2ccd6998'],
 };
 
-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 !== '~') {
-    return false;
-  }
-
-  return (
-    versionInResolutions.startsWith(desiredVersion) ||
-    versionInResolutions.startsWith('~' + desiredVersion)
-  );
+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 = (
-  node: ObjectExpression,
-  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 = node.properties.some(
-    (p) =>
-      p.type === 'Property' && p.key.type === 'Literal' && p.key.value === pkg,
-  );
-
-  if (!resolutionExist) {
-    return optional;
-  }
-
-  const resolutionExistAndMatch = node.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;
+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 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(
-                  packageResolutions as ObjectExpression,
-                  key,
-                  value,
-                  !isRootPackageJson,
-                );
-              })
-            ) {
-              return context.report({
-                node,
-                messageId: 'invalidPackageResolution',
-              });
-            }
-          }
-        }
-      },
-    };
-  },
+	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 +1,65 @@
 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('test prefix rule', () => {
-  beforeEach(() => {
-    mockPath = 'test/package.json';
+	beforeEach(() => {
+		mockPath = 'test/package.json';
 
-    mockPackageJson = {
-      'platform-feature-flags': {
-        'prefix-flag': {
-          type: 'boolean',
-        },
-        'no-prefix-flag': {
-          type: 'boolean',
-        },
-      },
-    };
-  });
+		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',
-            },
-          },
-        ],
-      },
-    ],
-  });
+	// 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',
+						},
+					},
+				],
+			},
+		],
+	});
 });