@atlaskit/eslint-plugin-platform 0.7.5 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/eslint-plugin-platform
 
+## 0.9.0
+
+### Minor Changes
+
+- [#146603](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/146603)
+  [`73a0361be46a2`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/73a0361be46a2) -
+  Created new rule `@atlaskit/platform/ensure-valid-bin-values` which validates bin values in
+  package.json files are valid point to files, not directories.
+
+## 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,8 @@ 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 _ensureValidBinValues = _interopRequireDefault(require("./rules/ensure-valid-bin-values"));
 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 +37,8 @@ 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,
+  'ensure-valid-bin-values': _ensureValidBinValues.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-bin-values/index.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = require("path");
+var _handleAstObject = require("../util/handle-ast-object");
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+var cwd = process.cwd();
+function checkIsAllBinValuesAreValid(node, packageDir) {
+  var binObj = (0, _handleAstObject.getObjectPropertyAsObject)(node, 'bin');
+  if (!binObj || !Array.isArray(binObj.properties)) {
+    return true;
+  }
+  return binObj.properties.every(function (p) {
+    if (p.type === 'Property' && p.value.type === 'Literal') {
+      try {
+        var binValue = String(p.value.value);
+        var pathToBin = (0, _path.resolve)(cwd, packageDir, binValue);
+        // Ignore bin values that point to dist as these files don't always exist
+        if (binValue.startsWith('./dist/')) {
+          return true;
+        }
+        return _fs.default.statSync(pathToBin).isFile();
+      } catch (err) {
+        return false;
+      }
+    }
+    // If it's not a property or doesn't have a literal value, consider it invalid
+    return false;
+  });
+}
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: "Ensures bin values in package.json files are valid.",
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      invalidBinValue: "Invalid bin value. Ensure that the value points to a file and not a directory."
+    }
+  },
+  create: function create(context) {
+    var fileName = context.getFilename();
+    return {
+      ObjectExpression: function ObjectExpression(node) {
+        if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+        var isAllBinValuesValid = checkIsAllBinValuesAreValid(node, (0, _path.dirname)(fileName));
+        if (isAllBinValuesValid) {
+          return;
+        }
+        return context.report({
+          node: node,
+          messageId: 'invalidBinValue'
+        });
+      }
+    };
+  }
+};
+var _default = exports.default = rule;

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,8 @@ 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 ensureValidBinValues from './rules/ensure-valid-bin-values';
 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 +29,8 @@ export const rules = {
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'ensure-atlassian-team': ensureAtlassianTeam,
   'ensure-critical-dependency-resolutions': ensureCriticalDependencyResolutions,
+  'ensure-valid-workspace-protocol-usage': ensureValidWorkspaceProtocolUsage,
+  'ensure-valid-bin-values': ensureValidBinValues,
   'no-duplicate-dependencies': noDuplicateDependencies,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,

package/dist/es2019/rules/ensure-valid-bin-values/index.js

@@ -0,0 +1,60 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import fs from 'fs';
+import { resolve, dirname } from 'path';
+import { getObjectPropertyAsObject } from '../util/handle-ast-object';
+const cwd = process.cwd();
+function checkIsAllBinValuesAreValid(node, packageDir) {
+  const binObj = getObjectPropertyAsObject(node, 'bin');
+  if (!binObj || !Array.isArray(binObj.properties)) {
+    return true;
+  }
+  return binObj.properties.every(p => {
+    if (p.type === 'Property' && p.value.type === 'Literal') {
+      try {
+        const binValue = String(p.value.value);
+        const pathToBin = resolve(cwd, packageDir, binValue);
+        // Ignore bin values that point to dist as these files don't always exist
+        if (binValue.startsWith('./dist/')) {
+          return true;
+        }
+        return fs.statSync(pathToBin).isFile();
+      } catch (err) {
+        return false;
+      }
+    }
+    // If it's not a property or doesn't have a literal value, consider it invalid
+    return false;
+  });
+}
+const rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: `Ensures bin values in package.json files are valid.`,
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      invalidBinValue: `Invalid bin value. Ensure that the value points to a file and not a directory.`
+    }
+  },
+  create(context) {
+    const fileName = context.getFilename();
+    return {
+      ObjectExpression: node => {
+        if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+        const isAllBinValuesValid = checkIsAllBinValuesAreValid(node, dirname(fileName));
+        if (isAllBinValuesValid) {
+          return;
+        }
+        return context.report({
+          node,
+          messageId: 'invalidBinValue'
+        });
+      }
+    };
+  }
+};
+export default rule;

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,8 @@ 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 ensureValidBinValues from './rules/ensure-valid-bin-values';
 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 +32,8 @@ export var rules = {
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'ensure-atlassian-team': ensureAtlassianTeam,
   'ensure-critical-dependency-resolutions': ensureCriticalDependencyResolutions,
+  'ensure-valid-workspace-protocol-usage': ensureValidWorkspaceProtocolUsage,
+  'ensure-valid-bin-values': ensureValidBinValues,
   'no-duplicate-dependencies': noDuplicateDependencies,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,

package/dist/esm/rules/ensure-valid-bin-values/index.js

@@ -0,0 +1,60 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import fs from 'fs';
+import { resolve, dirname } from 'path';
+import { getObjectPropertyAsObject } from '../util/handle-ast-object';
+var cwd = process.cwd();
+function checkIsAllBinValuesAreValid(node, packageDir) {
+  var binObj = getObjectPropertyAsObject(node, 'bin');
+  if (!binObj || !Array.isArray(binObj.properties)) {
+    return true;
+  }
+  return binObj.properties.every(function (p) {
+    if (p.type === 'Property' && p.value.type === 'Literal') {
+      try {
+        var binValue = String(p.value.value);
+        var pathToBin = resolve(cwd, packageDir, binValue);
+        // Ignore bin values that point to dist as these files don't always exist
+        if (binValue.startsWith('./dist/')) {
+          return true;
+        }
+        return fs.statSync(pathToBin).isFile();
+      } catch (err) {
+        return false;
+      }
+    }
+    // If it's not a property or doesn't have a literal value, consider it invalid
+    return false;
+  });
+}
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: "Ensures bin values in package.json files are valid.",
+      recommended: true
+    },
+    hasSuggestions: false,
+    messages: {
+      invalidBinValue: "Invalid bin value. Ensure that the value points to a file and not a directory."
+    }
+  },
+  create: function create(context) {
+    var fileName = context.getFilename();
+    return {
+      ObjectExpression: function ObjectExpression(node) {
+        if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
+          return;
+        }
+        var isAllBinValuesValid = checkIsAllBinValuesAreValid(node, dirname(fileName));
+        if (isAllBinValuesValid) {
+          return;
+        }
+        return context.report({
+          node: node,
+          messageId: 'invalidBinValue'
+        });
+      }
+    };
+  }
+};
+export default rule;

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,8 @@ 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;
+    'ensure-valid-bin-values': 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-bin-values/index.d.ts

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

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,8 @@ 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;
+    'ensure-valid-bin-values': 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-bin-values/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/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.9.0",
 	"author": "Atlassian Pty Ltd",
 	"atlassian": {
 		"team": "UIP Dev Infra",

package/src/index.tsx

@@ -9,6 +9,8 @@ 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 ensureValidBinValues from './rules/ensure-valid-bin-values';
 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 +30,8 @@ export const rules = {
 	'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
 	'ensure-atlassian-team': ensureAtlassianTeam,
 	'ensure-critical-dependency-resolutions': ensureCriticalDependencyResolutions,
+	'ensure-valid-workspace-protocol-usage': ensureValidWorkspaceProtocolUsage,
+	'ensure-valid-bin-values': ensureValidBinValues,
 	'no-duplicate-dependencies': noDuplicateDependencies,
 	'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
 	'no-pre-post-install-scripts': noPreAndPostInstallScripts,

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

@@ -0,0 +1,158 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+const cwd = process.cwd();
+
+const mockValidBinPaths = [
+	`${cwd}/packages/foo/run-ts.bin`,
+	`${cwd}/packages/foo/scripts/run-ts.bin`,
+	`${cwd}/packages/foo/bar/run-ts.ts`,
+	`${cwd}/packages/foo/bar/scripts/run-ts.ts`,
+	`${cwd}/packages/baz/run-ts.js`,
+	`${cwd}/packages/baz/scripts/run-ts.js`,
+];
+
+jest.mock('fs', () => {
+	const actual = jest.requireActual('fs');
+	return {
+		...actual,
+		statSync: jest.fn((stat: string) => ({
+			isFile: jest.fn(() => mockValidBinPaths.includes(stat)),
+		})),
+	};
+});
+
+describe('test ensure-valid-bin-values rule', () => {
+	tester.run('ensure-valid-bin-values', rule, {
+		valid: [
+			// .bin files are valid
+			{
+				code: `const foo = {
+            "bin": {
+              "run-ts": "./run-ts.bin",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+			},
+			{
+				code: `const foo = {
+            "bin": {
+              "run-ts": "./scripts/run-ts.bin",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+			},
+			// .ts files are valid
+			{
+				code: `const foo = {
+            "bin": {
+              "run-ts": "./run-ts.ts",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/bar/package.json`,
+			},
+			{
+				code: `const foo = {
+            "bin": {
+              "run-ts": "./scripts/run-ts.ts",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/bar/package.json`,
+			},
+			// .js files are valid
+			{
+				code: `const foo = {
+            "bin": {
+              "run-ts": "./run-ts.js",
+            }
+        }`,
+				filename: `${cwd}/packages/baz/package.json`,
+			},
+			{
+				code: `const foo = {
+        	"bin": {
+              "run-ts": "./scripts/run-ts.js",
+            }
+        }`,
+				filename: `${cwd}/packages/baz/package.json`,
+			},
+			// dist paths are valid
+			{
+				code: `const foo = {
+        	"bin": {
+              "run-ts": "./dist/run-ts.js",
+            }
+        }`,
+				filename: `${cwd}/packages/baz/package.json`,
+			},
+		],
+		invalid: [
+			// Pointing to anything other than a file is invalid
+			{
+				code: `const foo = {
+          "bin": {
+              "run-ts": "./bin",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{
+						messageId: 'invalidBinValue',
+					},
+				],
+			},
+			{
+				code: `const foo = {
+          "bin": {
+              "run-ts": "./scripts/index",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{
+						messageId: 'invalidBinValue',
+					},
+				],
+			},
+			{
+				code: `const foo = {
+          "bin": {
+              "run-ts": "./scripts/bin",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{
+						messageId: 'invalidBinValue',
+					},
+				],
+			},
+			{
+				code: `const foo = {
+          "bin": {
+              "run-ts": "./",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{
+						messageId: 'invalidBinValue',
+					},
+				],
+			},
+			{
+				code: `const foo = {
+          "bin": {
+              "run-ts": "",
+            }
+        }`,
+				filename: `${cwd}/packages/foo/package.json`,
+				errors: [
+					{
+						messageId: 'invalidBinValue',
+					},
+				],
+			},
+		],
+	});
+});

package/src/rules/ensure-valid-bin-values/index.ts

@@ -0,0 +1,70 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import fs from 'fs';
+import { resolve, dirname } from 'path';
+import type { Rule } from 'eslint';
+import type { ObjectExpression } from 'estree';
+import { getObjectPropertyAsObject } from '../util/handle-ast-object';
+
+const cwd = process.cwd();
+
+function checkIsAllBinValuesAreValid(node: ObjectExpression, packageDir: string) {
+	const binObj = getObjectPropertyAsObject(node, 'bin');
+
+	if (!binObj || !Array.isArray(binObj.properties)) {
+		return true;
+	}
+
+	return binObj.properties.every((p) => {
+		if (p.type === 'Property' && p.value.type === 'Literal') {
+			try {
+				const binValue = String(p.value.value);
+				const pathToBin = resolve(cwd, packageDir, binValue);
+				// Ignore bin values that point to dist as these files don't always exist
+				if (binValue.startsWith('./dist/')) {
+					return true;
+				}
+				return fs.statSync(pathToBin).isFile();
+			} catch (err) {
+				return false;
+			}
+		}
+		// If it's not a property or doesn't have a literal value, consider it invalid
+		return false;
+	});
+}
+
+const rule: Rule.RuleModule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: `Ensures bin values in package.json files are valid.`,
+			recommended: true,
+		},
+		hasSuggestions: false,
+		messages: {
+			invalidBinValue: `Invalid bin value. Ensure that the value points to a file and not a directory.`,
+		},
+	},
+	create(context) {
+		const fileName = context.getFilename();
+		return {
+			ObjectExpression: (node: Rule.Node) => {
+				if (!fileName.endsWith('package.json') || node.type !== 'ObjectExpression') {
+					return;
+				}
+
+				const isAllBinValuesValid = checkIsAllBinValuesAreValid(node, dirname(fileName));
+				if (isAllBinValuesValid) {
+					return;
+				}
+
+				return context.report({
+					node,
+					messageId: 'invalidBinValue',
+				});
+			},
+		};
+	},
+};
+
+export default rule;

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;