@atlaskit/eslint-plugin-platform 0.2.5 → 0.3.0

package/src/index.tsx

@@ -4,8 +4,10 @@ import noPreAndPostInstallScripts from './rules/no-pre-post-installs';
 import ensureTestRunnerArguments from './rules/ensure-test-runner-arguments';
 import ensureTestRunnerNestedCount from './rules/ensure-test-runner-nested-count';
 import ensureAtlassianTeam from './rules/ensure-atlassian-team';
+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 noInvalidStorybookDecoratorUsage from './rules/no-invalid-storybook-decorator-usage';
 import ensurePublishValid from './rules/ensure-publish-valid';
 
@@ -15,6 +17,8 @@ export const rules = {
   'ensure-test-runner-arguments': ensureTestRunnerArguments,
   'ensure-test-runner-nested-count': ensureTestRunnerNestedCount,
   'ensure-atlassian-team': ensureAtlassianTeam,
+  'ensure-critical-dependency-resolutions': ensureCriticalDependencyResolutions,
+  'no-duplicate-dependencies': noDuplicateDependencies,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,
   'no-invalid-storybook-decorator-usage': noInvalidStorybookDecoratorUsage,
@@ -39,14 +43,32 @@ export const configs = {
   },
 };
 
+const jsonPrefix =
+  '/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, @typescript-eslint/semi, no-template-curly-in-string */ module.exports = ';
+
 export const processors = {
   'package-json-processor': {
     preprocess: (source: string) => {
       // augment the json into a js file
-      return [
-        `/* eslint-disable quote-props, comma-dangle, quotes, semi, eol-last, @typescript-eslint/semi, no-template-curly-in-string */ module.exports = ${source.trim()}`,
-      ];
+      return [jsonPrefix + source.trim()];
+    },
+    postprocess: (messages) => {
+      return messages[0].map((message) => {
+        const { fix } = message;
+        if (!fix) {
+          return message;
+        }
+
+        const offset = jsonPrefix.length;
+        return {
+          ...message,
+          fix: {
+            ...fix,
+            range: [fix.range[0] - offset, fix.range[1] - offset],
+          },
+        };
+      });
     },
-    postprocess: (errors) => errors[0],
+    supportsAutofix: true,
   } as Linter.Processor,
 };

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

@@ -0,0 +1,125 @@
+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": "4.9.5",
+            }
+        }`,
+        filename: `${cwd}/package.json`,
+      },
+      // Root package.json, have all of the correct resolutions with ~
+      {
+        code: `const foo = {
+            "resolutions": {
+                "@types/react": "~16.14.25",
+                "typescript": "~4.9.8",
+            }
+        }`,
+        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": "~4.9.8",
+                }
+            }`,
+        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": "4.5.8",
+            }
+        }`,
+        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": "~4.5.8",
+            }
+        }`,
+        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": "^4.9.5",
+            }
+        }`,
+        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": "4.5.8",
+            }
+        }`,
+        filename: `${cwd}/packages/packge/directory/package.json`,
+        errors: [
+          {
+            messageId: 'invalidPackageResolution',
+          },
+        ],
+      },
+    ],
+  });
+});

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

@@ -0,0 +1,113 @@
+import { findRootSync } from '@manypkg/find-root';
+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: '4.9',
+  '@types/react': '16.14',
+};
+
+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 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 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, value] of Object.entries(DESIRED_PKG_VERSIONS)) {
+            if (
+              !verifyResolutionFromObject(
+                packageResolutions as ObjectExpression,
+                key,
+                value,
+                !isRootPackageJson,
+              )
+            ) {
+              return context.report({
+                node,
+                messageId: 'invalidPackageResolution',
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/rules/ensure-publish-valid/index.ts

@@ -1,47 +1,8 @@
 import type { Rule } from 'eslint';
-import type {
-  ObjectExpression,
-  SimpleLiteral,
-  RegExpLiteral,
-  BigIntLiteral,
-} from 'estree';
-const getObjectPropertyAsLiteral = (
-  node: ObjectExpression,
-  property: string,
-): SimpleLiteral['value'] | RegExpLiteral['value'] | BigIntLiteral['value'] => {
-  const prop = node.properties.find(
-    (p) =>
-      p.type === 'Property' &&
-      p.key.type === 'Literal' &&
-      p.key.value === property,
-  );
-
-  // double check for property is to make typescript happy
-  if (prop?.type === 'Property' && prop?.value.type === 'Literal') {
-    return prop.value.value ?? null;
-  }
-
-  return null;
-};
-
-const getObjectPropertyAsObject = (
-  node: ObjectExpression,
-  property: string,
-): ObjectExpression | null => {
-  const prop = node.properties.find(
-    (p) =>
-      p.type === 'Property' &&
-      p.key.type === 'Literal' &&
-      p.key.value === property,
-  );
-
-  // double check for property is to make typescript happy
-  if (prop?.type === 'Property' && prop?.value.type === 'ObjectExpression') {
-    return prop.value ?? null;
-  }
-
-  return null;
-};
+import {
+  getObjectPropertyAsLiteral,
+  getObjectPropertyAsObject,
+} from '../util/handle-ast-object';
 
 type RuleOptions = {
   // exceptions to this rule, will be ignored

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

@@ -0,0 +1,116 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+describe('test no-duplicate-dependencies rule', () => {
+  tester.run('no-duplicate-dependencies-rule', rule, {
+    valid: [
+      {
+        code: `
+          module.exports = {
+            "dependencies": {
+              "foo": "^1.0.0",
+              "bar": "^2.0.0"
+            }
+          };
+        `,
+        filename: 'dependencies.json',
+      },
+      {
+        code: `
+          module.exports = {
+            "devDependencies": {
+              "foo": "^1.0.0",
+              "bar": "^2.0.0"
+            }
+          };
+        `,
+        filename: 'devDependencies.json',
+      },
+      {
+        code: `
+          module.exports = {
+            "dependencies": {
+              "foo": "^1.0.0",
+              "bar": "^2.0.0"
+            },
+            "devDependencies": {
+              "baz": "^3.0.0",
+              "qux": "^4.0.0"
+            }
+          };
+        `,
+        filename: 'devAndDependencies.json',
+      },
+    ],
+    invalid: [
+      {
+        code: `
+          module.exports = {
+            "dependencies": {
+              "foo": "^1.0.0",
+              "bar": "^2.0.0"
+            },
+            "devDependencies": {
+              "foo": "^1.0.0",
+              "baz": "^3.0.0",
+              "qux": "^4.0.0"
+            }
+          };
+        `,
+        output: `
+          module.exports = {
+            "dependencies": {
+              "foo": "^1.0.0",
+              "bar": "^2.0.0"
+            },
+            "devDependencies": {
+              "baz": "^3.0.0",
+              "qux": "^4.0.0"
+            }
+          };
+        `,
+        errors: [
+          {
+            data: {
+              name: 'foo',
+            },
+            messageId: 'unexpectedDuplicateDependency',
+          },
+        ],
+        filename: 'duplicateDependenciesFirst.json',
+      },
+      {
+        code: `
+          module.exports = {
+            "dependencies": {
+              "bar": "^1.0.0"
+            },
+            "devDependencies": {
+              "foo": "^2.0.0",
+              "bar": "^1.0.0"
+            }
+          };
+        `,
+        output: `
+          module.exports = {
+            "dependencies": {
+              "bar": "^1.0.0"
+            },
+            "devDependencies": {
+              "foo": "^2.0.0"
+            }
+          };
+        `,
+        errors: [
+          {
+            data: {
+              name: 'bar',
+            },
+            messageId: 'unexpectedDuplicateDependency',
+          },
+        ],
+        filename: 'duplicateDependenciesLast.json',
+      },
+    ],
+  });
+});

package/src/rules/no-duplicate-dependencies/index.ts

@@ -0,0 +1,83 @@
+import type { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'This rule disallows a dependency to be defined in both dependencies and devDependencies',
+      recommended: false,
+    },
+    fixable: 'code',
+    messages: {
+      unexpectedDuplicateDependency: 'Unexpected duplicate dependency {{name}}',
+    },
+  },
+  create(context) {
+    const dependencies = new Map();
+    const devDependencies = new Map();
+
+    return {
+      'ObjectExpression Property[key.value=dependencies] Property': (
+        node: Rule.Node,
+      ) => {
+        // @ts-expect-error
+        dependencies.set(node.key.value, node.key);
+      },
+      'ObjectExpression Property[key.value=devDependencies] Property': (
+        node: Rule.Node,
+      ) => {
+        // @ts-expect-error
+        devDependencies.set(node.key.value, node.key);
+      },
+      'Program:exit': () => {
+        for (const [dependency, node] of devDependencies) {
+          if (dependencies.has(dependency)) {
+            context.report({
+              data: {
+                name: dependency,
+              },
+              fix(fixer) {
+                const sourceCode = context.getSourceCode();
+                const property = node.parent;
+                const isLastLine =
+                  sourceCode.getTokenAfter(property)?.value === '}';
+                const end = property.loc.end;
+
+                if (!isLastLine) {
+                  return fixer.removeRange([
+                    sourceCode.getIndexFromLoc({
+                      line: property.loc.start.line,
+                      column: 0,
+                    }),
+                    sourceCode.getIndexFromLoc({
+                      line: end.line + 1,
+                      column: 0,
+                    }),
+                  ]);
+                }
+
+                const previousToken = sourceCode.getTokenBefore(property)!;
+
+                return fixer.removeRange([
+                  sourceCode.getIndexFromLoc({
+                    line: previousToken.loc.end.line,
+                    column: previousToken.loc.end.column - 1,
+                  }),
+                  sourceCode.getIndexFromLoc({
+                    line: end.line,
+                    column: end.column,
+                  }),
+                ]);
+              },
+              messageId: 'unexpectedDuplicateDependency',
+              node,
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/rules/util/handle-ast-object.ts

@@ -0,0 +1,44 @@
+import type {
+  ObjectExpression,
+  SimpleLiteral,
+  RegExpLiteral,
+  BigIntLiteral,
+} from 'estree';
+
+export const getObjectPropertyAsLiteral = (
+  node: ObjectExpression,
+  property: string,
+): SimpleLiteral['value'] | RegExpLiteral['value'] | BigIntLiteral['value'] => {
+  const prop = node.properties.find(
+    (p) =>
+      p.type === 'Property' &&
+      p.key.type === 'Literal' &&
+      p.key.value === property,
+  );
+
+  // double check for property is to make typescript happy
+  if (prop?.type === 'Property' && prop?.value.type === 'Literal') {
+    return prop.value.value ?? null;
+  }
+
+  return null;
+};
+
+export const getObjectPropertyAsObject = (
+  node: ObjectExpression,
+  property: string,
+): ObjectExpression | null => {
+  const prop = node.properties.find(
+    (p) =>
+      p.type === 'Property' &&
+      p.key.type === 'Literal' &&
+      p.key.value === property,
+  );
+
+  // double check for property is to make typescript happy
+  if (prop?.type === 'Property' && prop?.value.type === 'ObjectExpression') {
+    return prop.value ?? null;
+  }
+
+  return null;
+};

package/tmp/api-report-tmp.d.ts

@@ -37,6 +37,8 @@ export const rules: {
     'ensure-test-runner-arguments': Rule.RuleModule;
     'ensure-test-runner-nested-count': Rule.RuleModule;
     'ensure-atlassian-team': Rule.RuleModule;
+    'ensure-critical-dependency-resolutions': Rule.RuleModule;
+    'no-duplicate-dependencies': Rule.RuleModule;
     'no-invalid-feature-flag-usage': Rule.RuleModule;
     'no-pre-post-install-scripts': Rule.RuleModule;
     'no-invalid-storybook-decorator-usage': Rule.RuleModule;

package/tsconfig.app.json

@@ -0,0 +1,36 @@
+{
+  "extends": "../../../tsconfig.node.json",
+  "include": ["./src/**/*.ts", "./src/**/*.tsx"],
+  "exclude": [
+    "**/docs/**/*",
+    "**/__tests__/**/*",
+    "**/vr-tests/**/*",
+    "**/__perf__/**/*",
+    "**/*.test.*",
+    "**/test.*",
+    "**/test-*",
+    "**/examples.ts",
+    "**/examples.tsx",
+    "**/examples/*.ts",
+    "**/examples/*.tsx",
+    "**/examples/**/*.ts",
+    "**/examples/**/*.tsx",
+    "**/storybook/**/*",
+    "**/constellation/**/*",
+    ".storybook/*",
+    "./__fixtures__/**/*",
+    "./__generated__/**/*",
+    "./mocks/**/*",
+    "./__mocks__/**/*",
+    "**/mock.*",
+    "**/codemods/**/*.ts",
+    "**/codemods/**/*.tsx"
+  ],
+  "compilerOptions": {
+    "baseUrl": "./",
+    "lib": ["ES2021.String"],
+    "composite": true,
+    "outDir": "../../../tsDist/@atlaskit__eslint-plugin-platform/app"
+  },
+  "references": []
+}

package/tsconfig.dev.json

@@ -0,0 +1,40 @@
+{
+  "extends": "../../../tsconfig.node.json",
+  "include": [
+    "**/docs/**/*",
+    "**/__tests__/**/*",
+    "**/vr-tests/**/*",
+    "**/__perf__/**/*",
+    "**/*.test.*",
+    "**/test.*",
+    "**/test-*",
+    "**/examples.ts",
+    "**/examples.tsx",
+    "**/examples/*.ts",
+    "**/examples/*.tsx",
+    "**/examples/**/*.ts",
+    "**/examples/**/*.tsx",
+    "**/storybook/**/*",
+    "**/constellation/**/*",
+    ".storybook/*",
+    "./__fixtures__/**/*",
+    "./__generated__/**/*",
+    "./mocks/**/*",
+    "./__mocks__/**/*",
+    "**/mock.*",
+    "**/codemods/**/*.ts",
+    "**/codemods/**/*.tsx"
+  ],
+  "exclude": ["./dist/**/*", "./build/**/*", "./node_modules/**/*"],
+  "compilerOptions": {
+    "baseUrl": "./",
+    "lib": ["ES2021.String"],
+    "composite": true,
+    "outDir": "../../../tsDist/@atlaskit__eslint-plugin-platform/dev"
+  },
+  "references": [
+    {
+      "path": "tsconfig.app.json"
+    }
+  ]
+}