@spinnaker/eslint-plugin 3.0.0

package/create-rule.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+const yargs = require('yargs').usage('$0 <rulename>', 'create a new eslint rule', (_yargs) =>
+  _yargs.positional('rulename', { description: 'the name of the rule' }),
+);
+
+const { existsSync } = require('fs');
+const { readFile, writeFile, mkdir } = require('fs').promises;
+
+const prettier = require('prettier');
+const glob = require('fast-glob');
+const { camelCase } = require('lodash');
+
+const { rulename } = yargs.argv;
+const symbol = camelCase(rulename);
+
+const load = async (filename) => readFile(filename, 'utf-8');
+const store = async (filename, content) => writeFile(filename, content, 'utf-8');
+
+const prepend = async (filename, insertString) => {
+  const content = await load(filename);
+  return store(filename, `${insertString}${content}`);
+};
+
+const insertAfter = async (filename, insertString, matchString) => {
+  const content = await load(filename, 'utf-8');
+  const matchIdx = content.indexOf(matchString);
+  if (matchIdx === -1) {
+    throw new Error(`Did not find '${matchString}' in ${filename}`);
+  }
+  const prefix = content.substr(0, matchIdx + matchString.length);
+  const suffix = content.substr(matchIdx + matchString.length);
+  return store(filename, `${prefix}${insertString}${suffix}`);
+};
+
+const replaceInFile = async (srcFile, destFile, findPattern, replaceString) => {
+  const content = await load(srcFile);
+  return store(destFile, content.replace(findPattern, replaceString));
+};
+
+const formatFiles = async (globs) => {
+  const files = await glob(globs);
+  for (const file of files) {
+    await formatFile(file);
+  }
+};
+
+const formatFile = async (filepath) => {
+  const fileContent = await load(filepath, 'utf-8');
+  const prettierConfig = await prettier.resolveConfig(filepath);
+  const options = { ...prettierConfig, filepath };
+  return store(filepath, prettier.format(fileContent, options));
+};
+
+async function createRule() {
+  if (!existsSync('rules')) {
+    await mkdir('rules');
+  }
+
+  await replaceInFile(`template/template-rule.ts`, `rules/${rulename}.ts`, /RULENAME/g, rulename);
+  await replaceInFile(`template/template-rule.spec.ts`, `rules/${rulename}.spec.ts`, /RULENAME/g, rulename);
+  await prepend('eslint-plugin.ts', `import ${camelCase(rulename)} from './rules/${rulename}';\n`);
+  await insertAfter('eslint-plugin.ts', `\n    '${rulename}': ${camelCase(rulename)},`, 'rules: {');
+  await insertAfter('base.config.js', `\n    '@spinnaker/${rulename}': 2,`, 'rules: {');
+  await formatFiles([`rules/${rulename}.**`, 'eslint-plugin.js', 'base.config.js']);
+}
+
+createRule();

package/eslint-plugin.ts

@@ -0,0 +1,47 @@
+import apiDeprecation from './rules/api-deprecation';
+import apiNoSlashes from './rules/api-no-slashes';
+import apiNoUnusedChaining from './rules/api-no-unused-chaining';
+import importFromAliasNotNpm from './rules/import-from-alias-not-npm';
+import importFromNpmNotAlias from './rules/import-from-npm-not-alias';
+import importFromNpmNotRelative from './rules/import-from-npm-not-relative';
+import importFromPresentationNotCore from './rules/import-from-presentation-not-core';
+import importRelativeWithinSubpackage from './rules/import-relative-within-subpackage';
+import importSort from './rules/import-sort';
+import migrateToMockHttpClient from './rules/migrate-to-mock-http-client';
+import ngNoComponentClass from './rules/ng-no-component-class';
+import ngNoModuleExport from './rules/ng-no-module-export';
+import ngNoRequireAngularJS from './rules/ng-no-require-angularjs';
+import ngNoRequireModuleDeps from './rules/ng-no-require-module-deps';
+import ngStrictDI from './rules/ng-strictdi';
+import preferPromiseLike from './rules/prefer-promise-like';
+import react2angularWithErrorBoundary from './rules/react2angular-with-error-boundary';
+import restPreferStaticStringsInInitializer from './rules/rest-prefer-static-strings-in-initializer';
+
+const plugin = {
+  configs: {
+    base: require('./base.config.js'),
+    none: require('./none.config.js'),
+  },
+  rules: {
+    'api-deprecation': apiDeprecation,
+    'api-no-slashes': apiNoSlashes,
+    'api-no-unused-chaining': apiNoUnusedChaining,
+    'import-from-alias-not-npm': importFromAliasNotNpm,
+    'import-from-npm-not-alias': importFromNpmNotAlias,
+    'import-from-npm-not-relative': importFromNpmNotRelative,
+    'import-from-presentation-not-core': importFromPresentationNotCore,
+    'import-relative-within-subpackage': importRelativeWithinSubpackage,
+    'import-sort': importSort,
+    'migrate-to-mock-http-client': migrateToMockHttpClient,
+    'ng-no-component-class': ngNoComponentClass,
+    'ng-no-module-export': ngNoModuleExport,
+    'ng-no-require-angularjs': ngNoRequireAngularJS,
+    'ng-no-require-module-deps': ngNoRequireModuleDeps,
+    'ng-strictdi': ngStrictDI,
+    'prefer-promise-like': preferPromiseLike,
+    'react2angular-with-error-boundary': react2angularWithErrorBoundary,
+    'rest-prefer-static-strings-in-initializer': restPreferStaticStringsInInitializer,
+  },
+};
+
+export default plugin;

package/index.js

@@ -0,0 +1,6 @@
+// This registers Typescript compiler instance into node.js's require()
+const path = require('path');
+const project = path.resolve(__dirname, 'tsconfig.json');
+require('ts-node').register({ transpileOnly: true, project });
+
+module.exports = require('./eslint-plugin.ts').default;

package/newrule.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+if [[ -z $1 ]] ; then
+  echo "Enter name of rule, i.e.:"
+  echo "$0 lint-rule-name"
+  exit 1
+fi
+
+RULENAME=$1;
+
+
+sed -e "s/^  rules:.*/&'@spinnaker\/${RULENAME}': 2,/" -i '' base.config.js
+sed -e "s/^  rules:.*/&'${RULENAME}': require('.\/rules\/${RULENAME}'),/" -i '' eslint-plugin.js
+
+npx prettier --write base.config.js eslint-plugin.js
+
+
+
+# Write RULENAME.js
+(
+cat <<EndOfRuleFile
+'use strict';
+// @ts-check
+
+/**
+ * Import AST Types from 'estree'
+ * @typedef {import('estree').CallExpression} CallExpression
+ * @typedef {import('estree').ImportSpecifier} ImportSpecifier
+ */
+
+const _ = require('lodash/fp');
+
+const { getProgram } = require('../utils/utils');
+
+/** @type {RuleModule} */
+module.exports = {
+  create(context) {
+    return {
+      /** @param node {ImportSpecifier} */
+      ImportSpecifier(node) {
+        /** @type {ImportSpecifier[]} */
+        if (node.local && node.local.name === 'API') {
+          context.report({
+            node,
+            message: 'Do not import API',
+            fix: (fixer) => fixer.remove(node),
+          });
+        }
+      },
+    };
+  },
+  meta: {
+    fixable: 'code',
+    type: 'problem',
+    docs: {
+      description: 'Do not import API',
+    },
+  },
+};
+EndOfRuleFile
+) > rules/${RULENAME}.js
+
+
+# Write RULENAME.spec.js
+(
+cat <<EndOfSpecFile
+'use strict';
+
+const ruleTester = require('../utils/ruleTester');
+const rule = require('../rules/${RULENAME}');
+
+ruleTester.run('${RULENAME}', rule, {
+  valid: [
+    {
+      code: "import { Something } from 'somewhere';",
+    },
+  ],
+  invalid: [
+    {
+      code: "import { API } from '@spinnaker/core';",
+      output: "import {  } from '@spinnaker/core';",
+      errors: ["Do not import API"],
+    },
+  ],
+});
+
+EndOfSpecFile
+) > test/${RULENAME}.spec.js
+

package/none.config.js

@@ -0,0 +1,18 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: { sourceType: 'module' },
+  plugins: ['@typescript-eslint', '@spinnaker/eslint-plugin'],
+  extends: [],
+  rules: {},
+  env: {
+    browser: true,
+    node: true,
+    es6: true,
+    jasmine: true,
+  },
+  globals: {
+    angular: true,
+    $: true,
+    _: true,
+  },
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@spinnaker/eslint-plugin",
+  "version": "3.0.0",
+  "main": "index.js",
+  "license": "Apache-2.0",
+  "scripts": {
+    "create-rule": "create-rule.js",
+    "dev": "npm run test:debug",
+    "test": "jest",
+    "test:debug": "node --inspect ./node_modules/.bin/jest --runInBand --watch"
+  },
+  "dependencies": {
+    "lodash": "^4.17.20",
+    "ts-node": "*"
+  },
+  "devDependencies": {
+    "@babel/preset-typescript": "^7.15.0",
+    "@types/eslint": "^7.28.0",
+    "@types/estree": "*",
+    "@types/jest": "^26.0.24",
+    "@types/lodash": "^4.14.165",
+    "@types/node": "^16.4.13",
+    "@typescript-eslint/parser": "^4.29.1",
+    "@typescript-eslint/types": "^4.29.1",
+    "eslint": "^7.32.0",
+    "fast-glob": "^3.2.7",
+    "jest": "^27.0.6",
+    "prettier": "*",
+    "typescript": "^4.3.5"
+  },
+  "peerDependencies": {
+    "@typescript-eslint/eslint-plugin": "4.4.0",
+    "@typescript-eslint/parser": "4.4.0",
+    "eslint": "7.10.0",
+    "eslint-config-prettier": "6.12.0",
+    "eslint-plugin-react-hooks": "4.1.2"
+  },
+  "peerDevDependencies": [
+    "@typescript-eslint/eslint-plugin",
+    "@typescript-eslint/parser",
+    "eslint",
+    "eslint-config-prettier",
+    "eslint-plugin-react-hooks"
+  ],
+  "jest": {
+    "testPathIgnorePatterns": [
+      "<rootDir>/template"
+    ]
+  },
+  "gitHead": "2ddc8bd4f04d13a8712702cf75fca3cada520406"
+}

package/rules/api-deprecation.spec.ts

@@ -0,0 +1,79 @@
+import ruleTester from '../utils/ruleTester';
+import rule from './api-deprecation';
+
+ruleTester.run('api-deprecation', rule, {
+  valid: [
+    {
+      code: `REST('/path/to/endpoint').path(id).get();`,
+    },
+  ],
+
+  invalid: [
+    // Simple renames: .one(), .all(), .getList(), .withParams(), .remove()
+    {
+      code: `API.one('foo');`,
+      output: `API.path('foo');`,
+      errors: ['API.one() is deprecated.  Migrate from one() to path()'],
+    },
+    {
+      code: `API.all('foo');`,
+      output: `API.path('foo');`,
+      errors: ['API.all() is deprecated.  Migrate from all() to path()'],
+    },
+    {
+      code: `API.path('foo').getList();`,
+      output: `API.path('foo').get();`,
+      errors: ['API.getList() is deprecated.  Migrate from getList() to get()'],
+    },
+    {
+      code: `API.withParams('foo');`,
+      output: `API.query('foo');`,
+      errors: ['API.withParams() is deprecated.  Migrate from withParams() to query()'],
+    },
+    {
+      code: `API.remove('foo');`,
+      output: `API.delete('foo');`,
+      errors: ['API.remove() is deprecated.  Migrate from remove() to delete()'],
+    },
+    // .data(obj).post() -> .post(obj)
+    {
+      code: `API.path('foo').data({ key: 'val' }).post();`,
+      output: `API.path('foo').post({ key: 'val' });`,
+      errors: ['API.data() is deprecated.  Migrate from .data({}) to .put({}) or .post({})'],
+    },
+    // .data(obj).put() -> .put(obj)
+    {
+      code: `API.path('foo').data({ key: 'val' }).put();`,
+      output: `API.path('foo').put({ key: 'val' });`,
+      errors: ['API.data() is deprecated.  Migrate from .data({}) to .put({}) or .post({})'],
+    },
+    // .get() doesn't have queryparams args
+    {
+      code: `API.path('foo').get(queryParams);`,
+      output: `API.path('foo').query(queryParams).get();`,
+      errors: [
+        'Passing parameters to API.get() is deprecated.  Migrate from .get(queryparams) to .query(queryparams).get()',
+      ],
+    },
+    // .delete() doesn't have queryparams args
+    {
+      code: `API.path('foo').delete(queryParams);`,
+      output: `API.path('foo').query(queryParams).delete();`,
+      errors: [
+        'Passing parameters to API.delete() is deprecated.  Migrate from .delete(queryparams) to .query(queryparams).delete()',
+      ],
+    },
+    // .delete() doesn't have queryparams args
+    {
+      code: `API.path('foo').path(id);`,
+      output: `API.path('foo', id);`,
+      errors: ["Prefer API.path('foo', 'bar') over API.path('foo').path('bar')"],
+    },
+    // Migrate from API to REST()
+    {
+      code: `API.path('foo', id).withCache().get()`,
+      output: `REST().path('foo', id).withCache().get()`,
+      errors: ['API is deprecated, switch to REST()'],
+    },
+  ],
+});

package/rules/api-deprecation.ts

@@ -0,0 +1,254 @@
+import type { Rule } from 'eslint';
+import type { CallExpression, ImportDeclaration, ImportSpecifier, MemberExpression, Node } from 'estree';
+import * as _ from 'lodash/fp';
+
+import {
+  getCallChain,
+  getCallingIdentifier,
+  getProgram,
+  getVariableInitializer,
+  getVariableInScope,
+} from '../utils/utils';
+
+function isAPICall(context: Rule.RuleContext, node: CallExpression) {
+  // Find the call chain Identifier:
+  // API.one().all().get()
+  // ^^^
+  const callingIdentifier = getCallingIdentifier(node);
+  if (callingIdentifier && callingIdentifier.name === 'API') {
+    return true;
+  }
+
+  // If the calling identifier is a variable reference ...
+  // var foo = API.one(); foo.one().all().get();
+  //                      ^^^
+  // then find the variable initializer: var foo = API.one();
+  //                                               ^^^^^^^^^
+  const variable = getVariableInScope(context, callingIdentifier);
+  const initializer = getVariableInitializer(variable);
+  const initializerIdentifier = getCallingIdentifier(initializer);
+
+  return initializerIdentifier && initializerIdentifier.name === 'API';
+}
+
+const getCallName = _.get('callee.property.name');
+
+function isCallNamed(...callNames: string[]) {
+  return function (callExpression: CallExpression) {
+    const callName = getCallName(callExpression);
+    return callNames.includes(callName);
+  };
+}
+
+/**
+ * Returns a list of deprecated methods that need to be renamed and fixers to do so.
+ */
+function findMethodsToRename(callChain: CallExpression[]) {
+  const renames = {
+    getList: 'get',
+    withParams: 'query',
+    one: 'path',
+    all: 'path',
+    remove: 'delete',
+  };
+
+  const calls = callChain.map((call) => {
+    const from = getCallName(call) as keyof typeof renames;
+    const to = renames[from];
+    const fix = (fixer: Rule.RuleFixer) => fixer.replaceText((call.callee as MemberExpression).property, to);
+    return { call, fix, from, to };
+  });
+
+  // Only return calls that have a 'to' mapping in the renames object
+  return calls.filter((tuple) => !!tuple.to);
+}
+
+interface IRename {
+  from: string;
+  to: string;
+  fix: (fixer: Rule.RuleFixer) => Rule.Fix;
+}
+
+function reportSimpleRenames(context: Rule.RuleContext, node: Node, renames: IRename[]) {
+  // Strings for the message
+  const froms = [...new Set(renames.map((tuple) => tuple.from))].join('/');
+  const tos = [...new Set(renames.map((tuple) => tuple.to))].join('/');
+
+  return context.report({
+    node,
+    message: `API.${froms}() is deprecated.  Migrate from ${froms}() to ${tos}()`,
+    fix: (fixer) => renames.map((tuple) => tuple.fix(fixer)),
+  });
+}
+
+function reportDataMethod(context: Rule.RuleContext, node: Node, callChain: CallExpression[]) {
+  // Just the .data() calls
+  const dataCalls = callChain.filter(isCallNamed('data'));
+
+  // Find the corresponding put/post
+  const putOrPost = callChain.find((n) => ['put', 'post'].includes((n.callee as any).property.name));
+  const message = `API.data() is deprecated.  Migrate from .data({}) to .put({}) or .post({})`;
+
+  // If there is a single .data() and a .put() or .post() in the chain...
+  if (dataCalls.length !== 1 || !putOrPost) {
+    // Can't find a single .data({}) and .post()/.put() to auto-fix, so just report the problem to the user
+    return context.report({ node, message });
+  }
+
+  const call = dataCalls[0];
+  // get the text of the arguments passed to .data(ARGS)
+  const argsText = call.arguments.map((arg) => context.getSourceCode().getText(arg)).join(', ');
+  // @ts-ignore find the spot between the parentheses in -> post()
+  const putOrPostRangeEnd = putOrPost.callee.property.range[1] + 1;
+  // @ts-ignore Just after ".one()" in `.one().data(value)`
+  const previousCalleeRangeEnd = call.callee.object.range[1];
+  // The end of `.data(value)`
+  const dataRangeEnd = call.range[1];
+  return context.report({
+    node,
+    message,
+    fix: (fixer) => [
+      // Move "value" text from .data(value) into the put/post args, i.e.: .put(value)
+      fixer.replaceTextRange([putOrPostRangeEnd, putOrPostRangeEnd], argsText),
+      // Remove .data(value) entirely
+      fixer.replaceTextRange([previousCalleeRangeEnd, dataRangeEnd], ''),
+    ],
+  });
+}
+
+function reportGetsAndDeletesWithArgs(context: Rule.RuleContext, node: Node, getsAndDeletes: CallExpression[]) {
+  const callNames = [...new Set(getsAndDeletes.map(getCallName))].join('/');
+  const message = `Passing parameters to API.${callNames}() is deprecated.  Migrate from .${callNames}(queryparams) to .query(queryparams).${callNames}()`;
+
+  // Should be only one get/delete, but just in case, report without fixing:
+  if (getsAndDeletes.length > 1) {
+    return context.report({ node, message });
+  }
+
+  const call = getsAndDeletes[0];
+  const type = getCallName(call);
+  const argsText = call.arguments.map((arg) => context.getSourceCode().getText(arg)).join(', ');
+  const getCallStart = (call.callee as MemberExpression).property.range[0];
+  const getCallEnd = call.range[1];
+  const fix = (fixer: Rule.RuleFixer) =>
+    fixer.replaceTextRange([getCallStart, getCallEnd], `query(${argsText}).${type}()`);
+
+  return context.report({ node, message, fix });
+}
+
+function reportChainedPathAsVarargs(callChain: CallExpression[], context: Rule.RuleContext, node: Node) {
+  const message = `Prefer API.path('foo', 'bar') over API.path('foo').path('bar')`;
+
+  const fix = (fixer: Rule.RuleFixer) => {
+    const [firstPathCall, secondPathCall] = callChain;
+
+    const firstPathLastArg = firstPathCall['arguments'].slice().pop();
+    const secondPathStart = firstPathCall.range[1];
+    const secondPathEnd = secondPathCall.range[1];
+    const secondPathArgsText = secondPathCall['arguments']
+      .map((arg) => context.getSourceCode().getText(arg))
+      .join(', ');
+
+    return [
+      // Move the second .path(...) call's args to first .path() args list
+      fixer.insertTextAfter(firstPathLastArg, `, ${secondPathArgsText}`),
+      // Remove second .path()
+      fixer.removeRange([secondPathStart, secondPathEnd]),
+    ];
+  };
+
+  return context.report({ message, node, fix });
+}
+
+function reportAPIDeprecatedUseREST(node: Node, context: Rule.RuleContext, callChain: CallExpression[]) {
+  // Everything else is migrated, now migrate from API.path() to REST().path()
+  const message = 'API is deprecated, switch to REST()';
+  const API = (callChain[0].callee as MemberExpression).object;
+  const program = getProgram(node);
+  const allImports = program.body.filter((item) => item.type === 'ImportDeclaration') as ImportDeclaration[];
+  const importSpecifiers = allImports
+    .map((decl) => decl.specifiers)
+    .reduce((acc, x) => acc.concat(x), []) as ImportSpecifier[]; //flatten
+
+  const apiImport = importSpecifiers.find((specifier) => {
+    return specifier.imported && specifier.imported?.name === 'API';
+  });
+
+  return context.report({
+    message,
+    node,
+    fix: (fixer) => {
+      if (!apiImport) {
+        // Replace API with REST()
+        return fixer.replaceText(API, 'REST()');
+      }
+
+      return [
+        // Replace API with REST()
+        fixer.replaceText(API, 'REST()'),
+        fixer.replaceText(apiImport, 'REST'),
+      ];
+    },
+  });
+}
+
+const rule: Rule.RuleModule = {
+  create(context) {
+    return {
+      /**
+       * Look for chains of CallExpressions that are:
+       * - part of an API.xyz() call, e.g.: return API.xyz().get()
+       * - part of an xyz() call chained off a variable, e.g.: var foo = API.xyz(); foo.get()
+       * @param node {CallExpression}
+       */
+      CallExpression(node) {
+        if (node.parent.type === 'MemberExpression' || !isAPICall(context, node)) {
+          return undefined;
+        }
+
+        // an array of CallExpressions, i.e. for API.one().all().get() -> [.one, .all, .get]
+        const callChain = getCallChain(node);
+
+        // Migrate the simple method renames, i.e.: API.one() -> API.path()
+        const renames = findMethodsToRename(callChain);
+        if (renames.length) {
+          return reportSimpleRenames(context, node, renames);
+        }
+
+        // Migrate .data(postdata).post() -> .post(postdata)
+        // Migrate .data(putdata).put() -> .put(putdata)
+        if (callChain.some(isCallNamed('data'))) {
+          return reportDataMethod(context, node, callChain);
+        }
+
+        // Migrate .get(params) -> .query(params).get()
+        // Migrate .delete(params) -> .query(params).delete()
+        const getsAndDeletes = callChain.filter(isCallNamed('get', 'delete'));
+        if (getsAndDeletes.some((x) => x.arguments.length > 0)) {
+          return reportGetsAndDeletesWithArgs(context, node, getsAndDeletes);
+        }
+
+        // Migrate .path('foo').path('bar') -> .path('foo', 'bar')
+        const hasTwoChainedPathCalls = getCallName(callChain[0]) === 'path' && getCallName(callChain[1]) === 'path';
+        if (hasTwoChainedPathCalls) {
+          return reportChainedPathAsVarargs(callChain, context, node);
+        }
+
+        // Migrate from API.xyz() to REST().xyz()
+        const callingIdentifier = getCallingIdentifier(node);
+        if (callingIdentifier && callingIdentifier.name === 'API') {
+          return reportAPIDeprecatedUseREST(node, context, callChain);
+        }
+      },
+    };
+  },
+  meta: {
+    fixable: 'code',
+    type: 'problem',
+    docs: {
+      description: 'Migrate from API.xyz() to REST(path)',
+    },
+  },
+};
+
+export default rule;