@atlaskit/eslint-plugin-platform 2.4.2 → 2.6.0

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

@@ -0,0 +1,212 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+const cwd = process.cwd();
+
+jest.mock('@manypkg/find-root');
+
+jest.mock('@manypkg/get-packages', () => ({
+	getPackagesSync: () => {
+		return {
+			packages: [
+				// Private packages
+				{
+					packageJson: {
+						name: '@af/private-pkg',
+						private: true,
+					},
+				},
+				{
+					packageJson: {
+						name: '@atlassian/private-pkg',
+						private: true,
+					},
+				},
+				{
+					packageJson: {
+						name: '@atlassiansox/private-pkg',
+						private: true,
+					},
+				},
+				// Public packages
+				{
+					packageJson: {
+						name: '@atlassian/public-pkg',
+						publishConfig: { registry: 'https://pkg-registry.com' },
+					},
+				},
+				{
+					packageJson: {
+						name: '@atlassiansox/public-pkg',
+						publishConfig: { registry: 'https://pkg-registry.com' },
+					},
+				},
+				{
+					packageJson: {
+						name: '@atlaskit/public-pkg',
+						publishConfig: { registry: 'https://pkg-registry.com' },
+					},
+				},
+			],
+		};
+	},
+}));
+
+const getErrorMessage = (pkgName: string) =>
+	`Published package has private dependency '${pkgName}'. To resolve this error, remove the private dependency or set this package to private.`;
+
+describe('test ensure-no-private-dependencies', () => {
+	tester.run('ensure-no-private-dependencies', rule, {
+		valid: [
+			// Private and public dependencies are allowed in private '@af' scoped packages
+			{
+				code: `const foo = {
+				"name:": "@af/test",
+				"private": true,
+				"dependencies": {
+					"@af/private-pkg": "workspace:*",
+					"@af/public-pkg": "workspace:*",
+					"@atlassian/private-pkg": "workspace:*",
+					"@atlassian/public-pkg": "workspace:*",
+					"@atlassiansox/private-pkg": "workspace:*",
+					"@atlassiansox/public-pkg": "workspace:*",
+					"react": "root:*"
+				}
+			}`,
+				filename: `${cwd}/packages/fpp/package.json`,
+			},
+			// Private and public dependencies are allowed in private '@atlassian' scoped packages
+			{
+				code: `const foo = {
+				"name:": "@atlassian/test",
+				"private": true,
+				"dependencies": {
+					"@af/private-pkg": "workspace:*",
+					"@af/public-pkg": "workspace:*",
+					"@atlassian/private-pkg": "workspace:*",
+					"@atlassian/public-pkg": "workspace:*",
+					"@atlassiansox/private-pkg": "workspace:*",
+					"@atlassiansox/public-pkg": "workspace:*",
+					"react": "root:*"
+				}
+			}`,
+				filename: `${cwd}/packages/fpp/package.json`,
+			},
+			// Private dependencies are allowed in private '@atlassiansox' scoped packages
+			{
+				code: `const foo = {
+	        "name:": "@atlassiansox/test",
+	        "private": true,
+	        "dependencies": {
+	          "@af/private-pkg": "workspace:*",
+	          "@atlassian/private-pkg": "workspace:*",
+ 	          "@atlassiansox/private-pkg": "workspace:*",
+ 	          "react": "root:*"
+	        }
+	      }`,
+				filename: `${cwd}/packages/foo/package.json`,
+			},
+			// Private and public dependencies are allowed in private '@atlassiansox' scoped packages
+			{
+				code: `const foo = {
+				"name:": "@atlassiansox/test",
+				"private": true,
+				"dependencies": {
+	        "@af/private-pkg": "workspace:*",
+	        "@af/public-pkg": "workspace:*",
+	        "@atlassian/private-pkg": "workspace:*",
+	        "@atlassian/public-pkg": "workspace:*",
+	        "@atlassiansox/private-pkg": "workspace:*",
+	        "@atlassiansox/public-pkg": "workspace:*",
+	        "react": "root:*"
+				}
+			}`,
+				filename: `${cwd}/packages/fpp/package.json`,
+			},
+		],
+		invalid: [
+			// Disallow private dependencies in public '@atlaskit' scoped packages
+			{
+				code: `const foo = {
+	        "name": "@atlaskit/test",
+	        "publishConfig": { "registry": "https://pkg-registry.com" },
+	        "dependencies": {
+	          "@af/private-pkg": "workspace:*",
+	          "@atlassian/private-pkg": "workspace:*",
+ 	          "@atlassiansox/private-pkg": "workspace:*",
+ 	          "react": "root:*"
+	        }
+				}`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{
+						message:
+							"Published package has private dependency '@af/private-pkg'. To resolve this error, remove the private dependency or set this package to private.",
+					},
+					{
+						message:
+							"Published package has private dependency '@atlassian/private-pkg'. To resolve this error, remove the private dependency or set this package to private.",
+					},
+					{
+						message:
+							"Published package has private dependency '@atlassiansox/private-pkg'. To resolve this error, remove the private dependency or set this package to private.",
+					},
+				],
+			},
+			// Disallow private dependencies in public '@atlassian' scoped packages
+			{
+				code: `const foo = {
+	        "name": "@atlassian/test",
+	        "publishConfig": { "registry": "https://registry.npmjs.org/" },
+	        "dependencies": {
+	          "@af/private-pkg": "workspace:*",
+	          "@atlassian/private-pkg": "workspace:*",
+ 	          "@atlassiansox/private-pkg": "workspace:*"
+	        }
+	        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{ message: getErrorMessage('@af/private-pkg') },
+					{ message: getErrorMessage('@atlassian/private-pkg') },
+					{ message: getErrorMessage('@atlassiansox/private-pkg') },
+				],
+			},
+			// Disallow private dependencies in public '@atlassiansox' scoped packages
+			{
+				code: `const foo = {
+					"name": "@atlassian/test3",
+					"publishConfig": { "registry": "https://registry.npmjs.org/" },
+					"dependencies": {
+	          "@af/private-pkg": "workspace:*",
+	          "@atlassian/private-pkg": "workspace:*",
+ 	          "@atlassiansox/private-pkg": "workspace:*"
+					}
+					}`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{ message: getErrorMessage('@af/private-pkg') },
+					{ message: getErrorMessage('@atlassian/private-pkg') },
+					{ message: getErrorMessage('@atlassiansox/private-pkg') },
+				],
+			},
+			// Disallow private peer dependencies
+			{
+				code: `const foo = {
+	        "name": "@atlaskit/test",
+	        "publishConfig": { "registry": "https://registry.npmjs.org/" },
+	        "peerDependencies": {
+	          "@af/private-pkg": "workspace:*",
+	          "@atlassian/private-pkg": "workspace:*",
+ 	          "@atlassiansox/private-pkg": "workspace:*"
+	        }
+					}`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{ message: getErrorMessage('@af/private-pkg') },
+					{ message: getErrorMessage('@atlassian/private-pkg') },
+					{ message: getErrorMessage('@atlassiansox/private-pkg') },
+				],
+			},
+		],
+	});
+});

package/src/rules/ensure-no-private-dependencies/index.ts

@@ -0,0 +1,64 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type { Rule } from 'eslint';
+import { getObjectPropertyAsObject, getObjectPropertyAsLiteral } from '../util/handle-ast-object';
+import { getPackagesSync } from '@manypkg/get-packages';
+import { findRootSync } from '@manypkg/find-root';
+
+const root = findRootSync(process.cwd());
+const pkgs = getPackagesSync(root).packages;
+const pkgMap = new Map(pkgs.map((pkg) => [pkg.packageJson.name, pkg]));
+
+const rule: Rule.RuleModule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: `Ensures that private dependencies are not used in published packages.`,
+			recommended: true,
+		},
+		hasSuggestions: false,
+		messages: {
+			invalidPrivateDependency: `Published package has private dependency '{{ pkgName }}'. To resolve this error, remove the private dependency or set this package to private.`,
+		},
+	},
+	create(context) {
+		return {
+			ObjectExpression: async (node: Rule.Node) => {
+				// Only run this rule on package.json files
+				if (!context.filename.endsWith('package.json') || node.type !== 'ObjectExpression') {
+					return;
+				}
+
+				// Private dependencies can be used in private packages
+				const isPrivatePkg = getObjectPropertyAsLiteral(node, 'private') === true;
+				if (isPrivatePkg === true) {
+					return;
+				}
+
+				// Check for private dependencies in dependencies and peerDependencies
+				// Note: devDependencies are not checked here as they don't end up in consumer lockfiles
+				const dependencies = getObjectPropertyAsObject(node, 'dependencies');
+				const peerDependencies = getObjectPropertyAsObject(node, 'peerDependencies');
+
+				for (const obj of [dependencies, peerDependencies]) {
+					for (const p of obj?.properties || []) {
+						if (p.type === 'Property' && p.key.type === 'Literal') {
+							const key = p.key.value;
+							if (typeof key === 'string' && pkgMap.has(key)) {
+								const isPrivateDependency = pkgMap.get(key)?.packageJson.private === true;
+								if (isPrivateDependency) {
+									context.report({
+										node,
+										messageId: 'invalidPrivateDependency',
+										data: { pkgName: key },
+									});
+								}
+							}
+						}
+					}
+				}
+			},
+		};
+	},
+};
+
+export default rule;

package/src/rules/ensure-valid-bin-values/__tests__/unit/rule.test.ts

@@ -16,8 +16,9 @@ jest.mock('fs', () => {
 	const actual = jest.requireActual('fs');
 	return {
 		...actual,
-		statSync: jest.fn((stat: string) => ({
-			isFile: jest.fn(() => mockValidBinPaths.includes(stat)),
+		statSync: jest.fn((p: string) => ({
+			isFile: jest.fn(() => mockValidBinPaths.includes(p)),
+			isDirectory: jest.fn(() => actual.statSync(p).isDirectory()),
 		})),
 	};
 });

package/src/rules/ensure-valid-platform-yarn-protocol-usage/__tests__/unit/rule.test.ts

@@ -6,95 +6,43 @@ const cwd = process.cwd();
 describe('test ensure-valid-platform-yarn-protocol-usage rule', () => {
 	tester.run('workspace protocol', rule, {
 		valid: [
-			// Workspace protocol is allowed in private packages as dependencies
+			// Workspace protocol 'workspace:*' is allowed in packages as dependencies
 			{
 				code: `const foo = {
-            "private": true,
-            "dependencies": {
-              "@atlaskit/button": "workspace:^",
-              "@atlaskit/primitives": "workspace:*",
-              "@atlaskit/tokens": "workspace:*"
-            }
-        }`,
+	        "dependencies": {
+	          "@atlaskit/button": "workspace:*",
+	          "@atlaskit/primitives": "workspace:*",
+	          "@atlaskit/tokens": "workspace:*"
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 			},
-			// Workspace protocol is allowed in private packages as devDependencies
+			// Workspace protocol 'workspace:*' is allowed in packages as devDependencies
 			{
 				code: `const foo = {
-            "private": true,
-            "devDependencies": {
-              "@atlaskit/button": "workspace:^",
-              "@atlaskit/primitives": "workspace:^"
-            }
-        }`,
+	        "devDependencies": {
+	          "@atlaskit/button": "workspace:*",
+	          "@atlaskit/primitives": "workspace:*"
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 			},
-			// Workspace protocol is allowed in private packages dependencies and devDependencies
+			// Workspace protocol is allowed in packages dependencies and devDependencies
 			{
 				code: `const foo = {
-            "private": true,
-            "dependencies": {
-              "@atlaskit/button": "workspace:^",
-              "@atlaskit/primitives": "workspace:^"
-            },
-            "devDependencies": {
-              "@atlaskit/button": "workspace:^",
-              "@atlaskit/primitives": "workspace:^"
-            }
-        }`,
+	        "dependencies": {
+	          "@atlaskit/button": "workspace:*",
+	          "@atlaskit/primitives": "workspace:*"
+	        },
+	        "devDependencies": {
+	          "@atlaskit/button": "workspace:*",
+	          "@atlaskit/primitives": "workspace:*"
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 			},
 		],
-		invalid: [
-			// Workspace protocol is not allowed in public packages as dependencies
-			{
-				code: `const foo = {
-            "dependencies": {
-              "@atlaskit/button": "workspace:^",
-              "@atlaskit/primitives": "workspace:*",
-              "@atlaskit/tokens": "workspace:*"
-            }
-        }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidWorkspaceProtocolUsage',
-					},
-				],
-			},
-			// Workspace protocol is not allowed in public packages as devDependencies
-			{
-				code: `const foo = {
-            "devDependencies": {
-              "@atlaskit/button": "workspace:^",
-              "@atlaskit/primitives": "^1.0.0"
-            }
-        }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidWorkspaceProtocolUsage',
-					},
-				],
-			},
-			// Workspace protocol is not allowed in public packages as dependencies and devDependencies
-			{
-				code: `const foo = {
-            "dependencies": {
-              "@atlaskit/button": "workspace:^"
-            },
-            "devDependencies": {
-              "@atlaskit/primitives": "workspace:^"
-            }
-        }`,
-				filename: `${cwd}/packages/foo/package.json`,
-				errors: [
-					{
-						messageId: 'invalidWorkspaceProtocolUsage',
-					},
-				],
-			},
-		],
+		invalid: [],
 	});
 
 	tester.run('root: protocol', rule, {
@@ -104,10 +52,10 @@ describe('test ensure-valid-platform-yarn-protocol-usage rule', () => {
 			// 'root:' protocol is not allowed in packages as dependencies
 			{
 				code: `const foo = {
-            "dependencies": {
-              "react": "root:*",
-            }
-        }`,
+	        "dependencies": {
+	          "react": "root:*",
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 				errors: [
 					{
@@ -118,11 +66,11 @@ describe('test ensure-valid-platform-yarn-protocol-usage rule', () => {
 			// 'root:' protocol is not allowed in private packages as dependencies
 			{
 				code: `const foo = {
-            "private": true,
-            "dependencies": {
-              "react": "root:*",
-            }
-        }`,
+	        "private": true,
+	        "dependencies": {
+	          "react": "root:*",
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 				errors: [
 					{
@@ -133,10 +81,10 @@ describe('test ensure-valid-platform-yarn-protocol-usage rule', () => {
 			// 'root:' protocol is not allowed in public packages as devDependencies
 			{
 				code: `const foo = {
-            "devDependencies": {
-              "react": "root:*",
-            }
-        }`,
+	        "devDependencies": {
+	          "react": "root:*",
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 				errors: [
 					{
@@ -147,11 +95,11 @@ describe('test ensure-valid-platform-yarn-protocol-usage rule', () => {
 			// 'root:' protocol is not allowed in private packages as devDependencies
 			{
 				code: `const foo = {
-            "private": true,
-            "devDependencies": {
-              "react": "root:*",
-            }
-        }`,
+	        "private": true,
+	        "devDependencies": {
+	          "react": "root:*",
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 				errors: [
 					{
@@ -162,13 +110,13 @@ describe('test ensure-valid-platform-yarn-protocol-usage rule', () => {
 			// 'root:' protocol is not allowed in public packages as dependencies and devDependencies
 			{
 				code: `const foo = {
-            "dependencies": {
-              "lodash": "root:*"
-            },
-            "devDependencies": {
-              "react": "root:*"
-            }
-        }`,
+	        "dependencies": {
+	          "lodash": "root:*"
+	        },
+	        "devDependencies": {
+	          "react": "root:*"
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 				errors: [
 					{
@@ -179,14 +127,14 @@ describe('test ensure-valid-platform-yarn-protocol-usage rule', () => {
 			// 'root:' protocol is not allowed in private packages as dependencies and devDependencies
 			{
 				code: `const foo = {
-            "private": true,
-            "dependencies": {
-              "lodash": "root:*"
-            },
-            "devDependencies": {
-              "react": "root:*"
-            }
-        }`,
+	        "private": true,
+	        "dependencies": {
+	          "lodash": "root:*"
+	        },
+	        "devDependencies": {
+	          "react": "root:*"
+	        }
+	    }`,
 				filename: `${cwd}/packages/foo/package.json`,
 				errors: [
 					{

package/src/rules/ensure-valid-platform-yarn-protocol-usage/index.ts

@@ -1,9 +1,8 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import type { Rule } from 'eslint';
 import type { ObjectExpression } from 'estree';
-import { getObjectPropertyAsObject, getObjectPropertyAsLiteral } from '../util/handle-ast-object';
+import { getObjectPropertyAsObject } from '../util/handle-ast-object';
 
-const workspaceProtocolRegex = /^workspace:[\^~\*]$/;
 const rootProtocolRegex = /^root:[\^~\*]$/;
 
 /**
@@ -14,14 +13,12 @@ function getYarnProtocolsUsed(node: ObjectExpression) {
 
 	const dependencies = getObjectPropertyAsObject(node, 'dependencies');
 	const devDependencies = getObjectPropertyAsObject(node, 'devDependencies');
+	const peerDependencies = getObjectPropertyAsObject(node, 'peerDependencies');
 
-	for (const obj of [dependencies, devDependencies]) {
+	for (const obj of [dependencies, devDependencies, peerDependencies]) {
 		for (const p of obj?.properties || []) {
 			if (p.type === 'Property' && p.value.type === 'Literal') {
 				if (typeof p.value.value === 'string') {
-					if (workspaceProtocolRegex.test(p.value.value)) {
-						protocolsUsed.workspace = true;
-					}
 					if (rootProtocolRegex.test(p.value.value)) {
 						protocolsUsed.root = true;
 					}
@@ -42,7 +39,7 @@ const rule: Rule.RuleModule = {
 		},
 		hasSuggestions: false,
 		messages: {
-			invalidWorkspaceProtocolUsage: `The 'workspace:' protocol is not allowed in public packages. To resolve this error, either set the package to private or replace the 'workspace:' protocol with specific package versions (e.g. '^1.0.0').`,
+			invalidWorkspaceProtocolUsage: `The 'workspace:^'protocol is Used. To resolve this error, please use the 'workspace:*' protocol instead.`,
 			invalidRootProtocolUsage: `The 'root:' protocol is not allowed in platform packages. To resolve this error, replace the 'root:' protocol with specific package versions (e.g. '^1.0.0').`,
 		},
 	},
@@ -62,15 +59,6 @@ const rule: Rule.RuleModule = {
 						messageId: 'invalidRootProtocolUsage',
 					});
 				}
-
-				// The 'workspace:' protocol can not be used in public packages
-				const isPrivatePackage = getObjectPropertyAsLiteral(node, 'private') === true;
-				if (!isPrivatePackage && yarnProtocolsUsed.workspace) {
-					context.report({
-						node,
-						messageId: 'invalidWorkspaceProtocolUsage',
-					});
-				}
 			},
 		};
 	},

package/src/rules/feature-gating/no-preconditioning/index.tsx

@@ -68,7 +68,7 @@ const rule: Rule.RuleModule = {
 		},
 		messages: {
 			useConfig:
-				'Do not precondition gates or experiments with another gate. Configure this in Statsig instead to reduce unnecessary code and simplify cleanup.',
+				'Do not precondition gates or experiments with another gate. Configure this in Statsig instead to reduce unnecessary code, simplify cleanup and to ensure accurate exposures in Statsig.',
 			incorrectExposure:
 				'Evaluate gates or experiments at the end of your logical expression to ensure exposure is tracked correctly.',
 		},