@atlaskit/eslint-plugin-platform 0.7.5 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @atlaskit/eslint-plugin-platform
 
+## 0.8.0
+
+### Minor Changes
+
+- [#143784](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/143784)
+  [`dd1180ff23e22`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/dd1180ff23e22) -
+  Created new rule `@atlaskit/platform/ensure-valid-workspace-protocol-usage` which validates the
+  yarn workspace protocol is only used in private packages.
+
 ## 0.7.5
 
 ### Patch Changes

package/dist/cjs/index.js

@@ -15,6 +15,7 @@ var _noDuplicateDependencies = _interopRequireDefault(require("./rules/no-duplic
 var _noInvalidFeatureFlagUsage = _interopRequireDefault(require("./rules/no-invalid-feature-flag-usage"));
 var _ensureFeatureFlagPrefix = _interopRequireDefault(require("./rules/ensure-feature-flag-prefix"));
 var _ensureCriticalDependencyResolutions = _interopRequireDefault(require("./rules/ensure-critical-dependency-resolutions"));
+var _ensureValidWorkspaceProtocolUsage = _interopRequireDefault(require("./rules/ensure-valid-workspace-protocol-usage"));
 var _noInvalidStorybookDecoratorUsage = _interopRequireDefault(require("./rules/no-invalid-storybook-decorator-usage"));
 var _ensurePublishValid = _interopRequireDefault(require("./rules/ensure-publish-valid"));
 var _ensureNativeAndAfExportsSynced = _interopRequireDefault(require("./rules/ensure-native-and-af-exports-synced"));
@@ -35,6 +36,7 @@ var rules = exports.rules = {
   'ensure-test-runner-nested-count': _ensureTestRunnerNestedCount.default,
   'ensure-atlassian-team': _ensureAtlassianTeam.default,
   'ensure-critical-dependency-resolutions': _ensureCriticalDependencyResolutions.default,
+  'ensure-valid-workspace-protocol-usage': _ensureValidWorkspaceProtocolUsage.default,
   'no-duplicate-dependencies': _noDuplicateDependencies.default,
   'no-invalid-feature-flag-usage': _noInvalidFeatureFlagUsage.default,
   'no-pre-post-install-scripts': _noPrePostInstalls.default,

package/dist/cjs/rules/ensure-valid-workspace-protocol-usage/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _handleAstObject = require("../util/handle-ast-object");
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+var workspaceProtocolRegex = /^workspace:[\^~\*]$/;
+
+/**
+ * Checks if the workspace protocol is used in either dependencies or devDependencies
+ */
+function checkIsWorkspaceProtocolUsed(node) {
+  var dependencies = (0, _handleAstObject.getObjectPropertyAsObject)(node, 'dependencies');
+  var devDependencies = (0, _handleAstObject.getObjectPropertyAsObject)(node, 'devDependencies');
+  return [dependencies, devDependencies].some(function (obj) {
+    return obj !== null && obj.properties.some(function (p) {
+      if (p.type === 'Property' && p.value.type === 'Literal') {
+        return typeof p.value.value === 'string' && workspaceProtocolRegex.test(p.value.value);
+      }
+    });
+  });
+}
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: "Ensures the workspace protocol is only used in private packages.",
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      invalidWorkspaceProtocolUsage: "The workspace protocol can not be used in public packages."
+    }
+  },
+  create: function create(context) {
+    var fileName = context.getFilename();
+    return {
+      ObjectExpression: function ObjectExpression(node) {
+        if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+
+        // Exit early if we are linting a private package
+        var isPrivatePackage = (0, _handleAstObject.getObjectPropertyAsLiteral)(node, 'private') === true;
+        if (isPrivatePackage) {
+          return;
+        }
+
+        // Check if the workspace protocol is used in either dependencies or devDependencies
+        var isWorkspaceProtocolused = checkIsWorkspaceProtocolUsed(node);
+        if (!isWorkspaceProtocolused) {
+          return;
+        }
+        return context.report({
+          node: node,
+          messageId: 'invalidWorkspaceProtocolUsage'
+        });
+      }
+    };
+  }
+};
+var _default = exports.default = rule;

package/dist/es2019/index.js

@@ -9,6 +9,7 @@ import noDuplicateDependencies from './rules/no-duplicate-dependencies';
 import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 import ensureFeatureFlagPrefix from './rules/ensure-feature-flag-prefix';
 import ensureCriticalDependencyResolutions from './rules/ensure-critical-dependency-resolutions';
+import ensureValidWorkspaceProtocolUsage from './rules/ensure-valid-workspace-protocol-usage';
 import noInvalidStorybookDecoratorUsage from './rules/no-invalid-storybook-decorator-usage';
 import ensurePublishValid from './rules/ensure-publish-valid';
 import ensureNativeAndAfExportsSynced from './rules/ensure-native-and-af-exports-synced';
@@ -27,6 +28,7 @@ export const rules = {
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'ensure-atlassian-team': ensureAtlassianTeam,
   'ensure-critical-dependency-resolutions': ensureCriticalDependencyResolutions,
+  'ensure-valid-workspace-protocol-usage': ensureValidWorkspaceProtocolUsage,
   'no-duplicate-dependencies': noDuplicateDependencies,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,

package/dist/es2019/rules/ensure-valid-workspace-protocol-usage/index.js

@@ -0,0 +1,59 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+import { getObjectPropertyAsObject, getObjectPropertyAsLiteral } from '../util/handle-ast-object';
+const workspaceProtocolRegex = /^workspace:[\^~\*]$/;
+
+/**
+ * Checks if the workspace protocol is used in either dependencies or devDependencies
+ */
+function checkIsWorkspaceProtocolUsed(node) {
+  const dependencies = getObjectPropertyAsObject(node, 'dependencies');
+  const devDependencies = getObjectPropertyAsObject(node, 'devDependencies');
+  return [dependencies, devDependencies].some(obj => {
+    return obj !== null && obj.properties.some(p => {
+      if (p.type === 'Property' && p.value.type === 'Literal') {
+        return typeof p.value.value === 'string' && workspaceProtocolRegex.test(p.value.value);
+      }
+    });
+  });
+}
+const rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: `Ensures the workspace protocol is only used in private packages.`,
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      invalidWorkspaceProtocolUsage: `The workspace protocol can not be used in public packages.`
+    }
+  },
+  create(context) {
+    const fileName = context.getFilename();
+    return {
+      ObjectExpression: node => {
+        if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+
+        // Exit early if we are linting a private package
+        const isPrivatePackage = getObjectPropertyAsLiteral(node, 'private') === true;
+        if (isPrivatePackage) {
+          return;
+        }
+
+        // Check if the workspace protocol is used in either dependencies or devDependencies
+        const isWorkspaceProtocolused = checkIsWorkspaceProtocolUsed(node);
+        if (!isWorkspaceProtocolused) {
+          return;
+        }
+        return context.report({
+          node,
+          messageId: 'invalidWorkspaceProtocolUsage'
+        });
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/index.js

@@ -12,6 +12,7 @@ import noDuplicateDependencies from './rules/no-duplicate-dependencies';
 import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 import ensureFeatureFlagPrefix from './rules/ensure-feature-flag-prefix';
 import ensureCriticalDependencyResolutions from './rules/ensure-critical-dependency-resolutions';
+import ensureValidWorkspaceProtocolUsage from './rules/ensure-valid-workspace-protocol-usage';
 import noInvalidStorybookDecoratorUsage from './rules/no-invalid-storybook-decorator-usage';
 import ensurePublishValid from './rules/ensure-publish-valid';
 import ensureNativeAndAfExportsSynced from './rules/ensure-native-and-af-exports-synced';
@@ -30,6 +31,7 @@ export var rules = {
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'ensure-atlassian-team': ensureAtlassianTeam,
   'ensure-critical-dependency-resolutions': ensureCriticalDependencyResolutions,
+  'ensure-valid-workspace-protocol-usage': ensureValidWorkspaceProtocolUsage,
   'no-duplicate-dependencies': noDuplicateDependencies,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,

package/dist/esm/rules/ensure-valid-workspace-protocol-usage/index.js

@@ -0,0 +1,59 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+import { getObjectPropertyAsObject, getObjectPropertyAsLiteral } from '../util/handle-ast-object';
+var workspaceProtocolRegex = /^workspace:[\^~\*]$/;
+
+/**
+ * Checks if the workspace protocol is used in either dependencies or devDependencies
+ */
+function checkIsWorkspaceProtocolUsed(node) {
+  var dependencies = getObjectPropertyAsObject(node, 'dependencies');
+  var devDependencies = getObjectPropertyAsObject(node, 'devDependencies');
+  return [dependencies, devDependencies].some(function (obj) {
+    return obj !== null && obj.properties.some(function (p) {
+      if (p.type === 'Property' && p.value.type === 'Literal') {
+        return typeof p.value.value === 'string' && workspaceProtocolRegex.test(p.value.value);
+      }
+    });
+  });
+}
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: "Ensures the workspace protocol is only used in private packages.",
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      invalidWorkspaceProtocolUsage: "The workspace protocol can not be used in public packages."
+    }
+  },
+  create: function create(context) {
+    var fileName = context.getFilename();
+    return {
+      ObjectExpression: function ObjectExpression(node) {
+        if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+
+        // Exit early if we are linting a private package
+        var isPrivatePackage = getObjectPropertyAsLiteral(node, 'private') === true;
+        if (isPrivatePackage) {
+          return;
+        }
+
+        // Check if the workspace protocol is used in either dependencies or devDependencies
+        var isWorkspaceProtocolused = checkIsWorkspaceProtocolUsed(node);
+        if (!isWorkspaceProtocolused) {
+          return;
+        }
+        return context.report({
+          node: node,
+          messageId: 'invalidWorkspaceProtocolUsage'
+        });
+      }
+    };
+  }
+};
+export default rule;

package/dist/types/index.d.ts

@@ -6,6 +6,7 @@ export declare const rules: {
     'ensure-test-runner-nested-count': import("eslint").Rule.RuleModule;
     'ensure-atlassian-team': import("eslint").Rule.RuleModule;
     'ensure-critical-dependency-resolutions': import("eslint").Rule.RuleModule;
+    'ensure-valid-workspace-protocol-usage': import("eslint").Rule.RuleModule;
     'no-duplicate-dependencies': import("eslint").Rule.RuleModule;
     'no-invalid-feature-flag-usage': import("eslint").Rule.RuleModule;
     'no-pre-post-install-scripts': import("eslint").Rule.RuleModule;

package/dist/types/rules/ensure-valid-workspace-protocol-usage/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/types-ts4.5/index.d.ts

@@ -6,6 +6,7 @@ export declare const rules: {
     'ensure-test-runner-nested-count': import("eslint").Rule.RuleModule;
     'ensure-atlassian-team': import("eslint").Rule.RuleModule;
     'ensure-critical-dependency-resolutions': import("eslint").Rule.RuleModule;
+    'ensure-valid-workspace-protocol-usage': import("eslint").Rule.RuleModule;
     'no-duplicate-dependencies': import("eslint").Rule.RuleModule;
     'no-invalid-feature-flag-usage': import("eslint").Rule.RuleModule;
     'no-pre-post-install-scripts': import("eslint").Rule.RuleModule;

package/dist/types-ts4.5/rules/ensure-valid-workspace-protocol-usage/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@atlaskit/eslint-plugin-platform",
 	"description": "The essential plugin for use with Atlassian frontend platform tools",
-	"version": "0.7.5",
+	"version": "0.8.0",
 	"author": "Atlassian Pty Ltd",
 	"atlassian": {
 		"team": "UIP Dev Infra",

package/src/index.tsx

@@ -9,6 +9,7 @@ import noDuplicateDependencies from './rules/no-duplicate-dependencies';
 import noInvalidFeatureFlagUsage from './rules/no-invalid-feature-flag-usage';
 import ensureFeatureFlagPrefix from './rules/ensure-feature-flag-prefix';
 import ensureCriticalDependencyResolutions from './rules/ensure-critical-dependency-resolutions';
+import ensureValidWorkspaceProtocolUsage from './rules/ensure-valid-workspace-protocol-usage';
 import noInvalidStorybookDecoratorUsage from './rules/no-invalid-storybook-decorator-usage';
 import ensurePublishValid from './rules/ensure-publish-valid';
 import ensureNativeAndAfExportsSynced from './rules/ensure-native-and-af-exports-synced';
@@ -28,6 +29,7 @@ export const rules = {
 	'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
 	'ensure-atlassian-team': ensureAtlassianTeam,
 	'ensure-critical-dependency-resolutions': ensureCriticalDependencyResolutions,
+	'ensure-valid-workspace-protocol-usage': ensureValidWorkspaceProtocolUsage,
 	'no-duplicate-dependencies': noDuplicateDependencies,
 	'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
 	'no-pre-post-install-scripts': noPreAndPostInstallScripts,

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

@@ -0,0 +1,99 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+const cwd = process.cwd();
+
+describe('test ensure-valid-workspace-protocol-usage rule', () => {
+	tester.run('ensure-valid-workspace-protocol-usage', rule, {
+		// Workspace protocol is allowed in private packages as dependencies
+		valid: [
+			{
+				code: `const foo = {
+            "private": true,
+            "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
+			{
+				code: `const foo = {
+            "private": true,
+            "devDependencies": {
+              "@atlaskit/button": "workspace:^",
+              "@atlaskit/primitives": "workspace:^"
+            }
+        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+			},
+			// Workspace protocol is allowed in private packages dependencies and devDependencies
+			{
+				code: `const foo = {
+            "private": true,
+            "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',
+					},
+				],
+			},
+		],
+	});
+});

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

@@ -0,0 +1,67 @@
+// 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';
+
+const workspaceProtocolRegex = /^workspace:[\^~\*]$/;
+
+/**
+ * Checks if the workspace protocol is used in either dependencies or devDependencies
+ */
+function checkIsWorkspaceProtocolUsed(node: ObjectExpression) {
+	const dependencies = getObjectPropertyAsObject(node, 'dependencies');
+	const devDependencies = getObjectPropertyAsObject(node, 'devDependencies');
+	return [dependencies, devDependencies].some((obj) => {
+		return (
+			obj !== null &&
+			obj.properties.some((p) => {
+				if (p.type === 'Property' && p.value.type === 'Literal') {
+					return typeof p.value.value === 'string' && workspaceProtocolRegex.test(p.value.value);
+				}
+			})
+		);
+	});
+}
+
+const rule: Rule.RuleModule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: `Ensures the workspace protocol is only used in private packages.`,
+			recommended: true,
+		},
+		hasSuggestions: false,
+		messages: {
+			invalidWorkspaceProtocolUsage: `The workspace protocol can not be used in public packages.`,
+		},
+	},
+	create(context) {
+		const fileName = context.getFilename();
+		return {
+			ObjectExpression: (node: Rule.Node) => {
+				if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
+					return;
+				}
+
+				// Exit early if we are linting a private package
+				const isPrivatePackage = getObjectPropertyAsLiteral(node, 'private') === true;
+				if (isPrivatePackage) {
+					return;
+				}
+
+				// Check if the workspace protocol is used in either dependencies or devDependencies
+				const isWorkspaceProtocolused = checkIsWorkspaceProtocolUsed(node);
+				if (!isWorkspaceProtocolused) {
+					return;
+				}
+
+				return context.report({
+					node,
+					messageId: 'invalidWorkspaceProtocolUsage',
+				});
+			},
+		};
+	},
+};
+
+export default rule;