@spinnaker/eslint-plugin 0.0.0-main-2

package/rules/api-no-slashes.spec.ts

@@ -0,0 +1,84 @@
+import rule from './api-no-slashes';
+import ruleTester from '../utils/ruleTester';
+const errorMessage =
+  `Do not include slashes in API.one() or API.all() calls because arguments to .one() and .all() get url encoded.` +
+  `Instead, of API.one('foo/bar'), split into multiple arguments: API.one('foo', 'bar').`;
+
+ruleTester.run('api-no-slashes', rule, {
+  valid: [
+    {
+      code: `API.one('foo', 'bar');`,
+    },
+    {
+      code: `const uri = "foo/bar/baz"; API.one(...uri.split('/'));`,
+    },
+  ],
+
+  invalid: [
+    {
+      code: `API.one('foo/bad');`,
+      output: `API.one('foo', 'bad');`,
+      errors: [errorMessage],
+    },
+    // Fixes slashes in chained .one().all().one() calls
+    {
+      code: `API.one('ok').one('ok').all('ok').one('foo/bad');`,
+      output: `API.one('ok').one('ok').all('ok').one('foo', 'bad');`,
+      errors: [errorMessage],
+    },
+    // Fixes slashes in varargs arguments
+    {
+      code: `API.one('ok').one('ok', 'foo/bad');`,
+      output: `API.one('ok').one('ok', 'foo', 'bad');`,
+      errors: [errorMessage],
+    },
+    // Variables which are initialized to a string literal with a slash transform to split+spread
+    {
+      code: `let foo = "foo/bad"; API.one(foo);`,
+      output: `let foo = "foo/bad"; API.one(...foo.split('/'));`,
+      errors: [errorMessage],
+    },
+    // Expressions with literal slashes transform to split+spread
+    {
+      code: "API.one(`foo/${bad}`, 'bad');",
+      output: "API.one(...(`foo/${bad}`).split('/'), 'bad');",
+      errors: [errorMessage],
+    },
+    // Variables whose initializer contains a slash
+    {
+      code: 'let foo = `foo/${variable}`; API.one(foo);',
+      output: "let foo = `foo/${variable}`; API.one(...foo.split('/'));",
+      errors: [errorMessage],
+    },
+    // Variables whose initializer contains a slash (anywhere)
+    {
+      code: 'let foo = "foo/bad" + variable; API.one(foo);',
+      output: `let foo = "foo/bad" + variable; API.one(...foo.split('/'));`,
+      errors: [errorMessage],
+    },
+    // Variables whose initializer contains a slash (mix of everything, still can be detected)
+    {
+      code: 'let foo = variable + `foo/${expr}` + "/bad/" + variable; API.one(foo);',
+      output: 'let foo = variable + `foo/${expr}` + "/bad/" + variable; API.one(...foo.split(\'/\'));',
+      errors: [errorMessage],
+    },
+    // Multiple errors, mix of styles
+    {
+      code: `const foo = "foo/bad"; API.all('api').one(foo).one('ok', 'bar/baz');`,
+      output: `const foo = "foo/bad"; API.all('api').one(...foo.split('/')).one('ok', 'bar', 'baz');`,
+      errors: [errorMessage, errorMessage], // two errors
+    },
+    // Detectable but unfixable
+    {
+      code: 'API.one(`foo/${template}`);',
+      output: "API.one(...(`foo/${template}`).split('/'));",
+      errors: [errorMessage], // two errors
+    },
+    // Detectable but unfixable
+    {
+      code: 'API.one("foo/" + expressions);',
+      output: `API.one(...("foo/" + expressions).split('/'));`,
+      errors: [errorMessage], // two errors
+    },
+  ],
+});

package/rules/api-no-slashes.ts

@@ -0,0 +1,148 @@
+import type { Rule } from 'eslint';
+import type { CallExpression, Identifier, Literal } from 'estree';
+import { get } from 'lodash';
+
+import { getCallingIdentifier, getVariableInScope, isMemberExpression } from '../utils/utils';
+
+/**
+ * No slashes in string literals passed to API.one() / API.all()
+ *
+ * @version 0.1.0
+ * @category
+ */
+const rule = function (context: Rule.RuleContext) {
+  return {
+    CallExpression: function (node: CallExpression) {
+      const callee = node.callee;
+      const args = node.arguments;
+
+      // .one() or .all()
+      const propertyName =
+        (isMemberExpression(callee) && callee.property && 'name' in callee.property && callee.property.name) || '';
+
+      if (propertyName !== 'one' && propertyName !== 'all') {
+        // console.log('not one or all');
+        return;
+      }
+
+      // API.all('ok').one('ok', 'foo/bad', 'ok')
+      // ^^^
+      if ((getCallingIdentifier(node) || {}).name !== 'API') {
+        // console.log(getCallingIdentifier(callee));
+        // console.log('calling identifier not API');
+        return;
+      }
+
+      // Get the source code (think .toString()) of the AST node and find a slash
+      // This isn't 100% accurate, but it's good enough.
+      function sourceCodeHasSlash(node) {
+        const text = node ? context.getSourceCode().getText(node) : '';
+        const splitOnSlash = /\.split\(['"`]\/['"]\)/;
+        return !!(text && text.includes('/') && !splitOnSlash.exec(text));
+      }
+
+      function isArgLiteralWithSlash(arg): arg is Literal {
+        return arg.type === 'Literal' && sourceCodeHasSlash(arg);
+      }
+
+      const isVariableInitializedWithSlash = (arg): arg is Identifier => {
+        if (arg.type !== 'Identifier') {
+          return false;
+        }
+
+        // Check if the arg is a variable
+        const variable = getVariableInScope(context, arg);
+        // Find the variable's initializer
+        const initializer = get(variable, 'defs[0].node.init', null);
+        // Check if that variable's initializer contains a slash
+        return sourceCodeHasSlash(initializer);
+      };
+
+      // Literal:
+      // .one(okArg, 'foo/' + barid)
+      const literalsWithSlashes = args.filter((arg) => isArgLiteralWithSlash(arg)) as Literal[];
+
+      // Initializer:
+      // var badArg = `foo/${barid}`;
+      // var badArg2 = 'foo/' + barid`;
+      // .one(badArg)
+      // .one(badArg2)
+      const varsWithSlashes = args.filter((arg) => isVariableInitializedWithSlash(arg)) as Identifier[];
+
+      // Expression:
+      // .one(`foo/${barid}`)
+      const expressionWithSlash = args.filter(
+        (arg) => !literalsWithSlashes.includes(arg as any) && sourceCodeHasSlash(arg),
+      );
+
+      if (literalsWithSlashes.length === 0 && varsWithSlashes.length === 0 && expressionWithSlash.length === 0) {
+        return;
+      }
+
+      const message =
+        `Do not include slashes in API.one() or API.all() calls because arguments to .one() and .all() get url encoded.` +
+        `Instead, of API.one('foo/bar'), split into multiple arguments: API.one('foo', 'bar').`;
+
+      const fix = (fixer) => {
+        // within:
+        //   API.one('foo/bad')
+        // replaces:
+        //   'foo/bad'
+        // with:
+        //   'foo', 'bad'
+        const literalArgFixes = literalsWithSlashes.map((arg) => {
+          const varArgs = (arg.value as string)
+            .split('/')
+            .map((segment) => "'" + segment + "'")
+            .join(', ');
+          return fixer.replaceText(arg, varArgs);
+        });
+
+        // within:
+        //   let myVar = 'foo/bad';
+        //   API.one(myVar)
+        // replaces argument:
+        //   myVar
+        // with:
+        //   ...myVar.split('/')
+        // i.e.:
+        //   API.one(...myVar.split('/'))
+        const variableArgFixes = varsWithSlashes.map((arg) => {
+          // Found a variable with an initializer containing a slash
+          // Change the argument to be a string-split + array-spread
+          const spread = `...${arg.name}.split('/')`;
+          return fixer.replaceText(arg, spread);
+        });
+
+        // within:
+        //   let prefix = 'foo/bad';
+        //   API.one(`${prefix}/path`)
+        // replaces with:
+        //   `${prefix}/path`
+        // with:
+        //   ...(`${prefix}/path`).split('/')
+        // i.e.:
+        //   API.one(...(`${prefix}/path`).split('/'))
+        const expressionWithSlashFixes = expressionWithSlash.map((arg) => {
+          const text = context.getSourceCode().getText(arg);
+          const spread = `...(${text}).split('/')`;
+          return fixer.replaceText(arg, spread);
+        });
+
+        return literalArgFixes.concat(variableArgFixes).concat(expressionWithSlashFixes);
+      };
+
+      context.report({ fix, node, message });
+    },
+  };
+};
+
+const ruleModule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    fixable: 'code',
+  },
+  create: rule,
+};
+
+export default ruleModule;

package/rules/api-no-unused-chaining.spec.ts

@@ -0,0 +1,26 @@
+import rule from '../rules/api-no-unused-chaining';
+import ruleTester from '../utils/ruleTester';
+const errorMessage = (text) => `Unused API.xyz() method chaining no longer works. Re-assign the result of: ${text}`;
+
+ruleTester.run('api-no-slashes', rule, {
+  valid: [
+    { code: `const fooBar = API.one('foo', 'bar');` },
+    { code: `let fooBar = API.one('foo', 'bar'); fooBar = fooBar.useCache()` },
+    { code: `const promise = API.one('foo', 'bar').all('baz').get();` },
+  ],
+
+  invalid: [
+    {
+      code: `API.one('foo/bad');`,
+      errors: [errorMessage(`API.one('foo/bad');`)],
+    },
+    {
+      code: `var foo = API.one('foo/bad'); foo.useCache(true);`,
+      errors: [errorMessage(`foo.useCache(true);`)],
+    },
+    {
+      code: `var foo = API.one('foo/bad'); foo.withParams({});`,
+      errors: [errorMessage(`foo.withParams({});`)],
+    },
+  ],
+});

package/rules/api-no-unused-chaining.ts

@@ -0,0 +1,47 @@
+import type { Rule } from 'eslint';
+import * as _ from 'lodash/fp';
+
+const isApiConfigCall = _.overSome([
+  _.matches({ property: { type: 'Identifier', name: 'one' } }),
+  _.matches({ property: { type: 'Identifier', name: 'all' } }),
+  _.matches({ property: { type: 'Identifier', name: 'useCache' } }),
+  _.matches({ property: { type: 'Identifier', name: 'withParams' } }),
+  _.matches({ property: { type: 'Identifier', name: 'data' } }),
+]);
+
+const falsePostitives = _.overSome([
+  _.matches({
+    property: { type: 'Identifier', name: 'data' },
+    object: { type: 'Identifier', name: '$element' },
+  }),
+]);
+
+const create = function (context) {
+  return {
+    ExpressionStatement(node) {
+      if (
+        node.expression.type === 'CallExpression' &&
+        isApiConfigCall(node.expression.callee) &&
+        !falsePostitives(node.expression.callee)
+      ) {
+        const text = context.getSourceCode().getText(node);
+        context.report({
+          node,
+          message: `Unused API.xyz() method chaining no longer works. Re-assign the result of: ${text}`,
+        });
+      }
+    },
+  };
+};
+
+const ruleModule: Rule.RuleModule = {
+  create,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Check for unused API.xyx() calls',
+    },
+  },
+};
+
+export default ruleModule;

package/rules/import-from-alias-not-npm.spec.ts

@@ -0,0 +1,22 @@
+import rule from './import-from-alias-not-npm';
+import ruleTester from '../utils/ruleTester';
+
+ruleTester.run('import-from-alias-not-npm', rule, {
+  valid: [
+    {
+      filename: '/root/spinnaker/deck/packages/amazon/package/amazon_source_file.ts',
+      code: `import { Anything } from '@spinnaker/core';`,
+    },
+  ],
+
+  invalid: [
+    {
+      filename: '/root/spinnaker/deck/packages/core/package/core_source_file.ts',
+      code: `import { Anything } from '@spinnaker/core';`,
+      output: `import { Anything } from 'core';`,
+      errors: [
+        'Do not use @spinnaker/core to import from core from code inside core.  Instead, use the core alias or a relative import',
+      ],
+    },
+  ],
+});

package/rules/import-from-alias-not-npm.ts

@@ -0,0 +1,53 @@
+import type { Rule } from 'eslint';
+import type { ImportDeclaration } from 'estree';
+
+import { getImportFromNpm, getSourceFileDetails } from '../utils/import-aliases';
+
+/**
+ * A group of rules that enforce spinnaker ES6 import alias conventions.
+ *
+ * Source code in a package (i.e., `core`) should not import from `@spinnaker/core`
+ *
+ * @version 0.1.0
+ * @category conventions
+ */
+const rule = function (context: Rule.RuleContext) {
+  const { ownPackage } = getSourceFileDetails(context.getFilename());
+  if (!ownPackage) {
+    return {};
+  }
+
+  return {
+    ImportDeclaration(node: ImportDeclaration) {
+      if (node.source.type !== 'Literal' || !node.source.value) {
+        return;
+      }
+      const importString = node.source.value as string;
+      const importFromNpm = getImportFromNpm(importString);
+      if (!importFromNpm || importFromNpm.pkg !== ownPackage) {
+        return;
+      }
+
+      const { pkg, importPathWithSlash } = importFromNpm;
+      const message =
+        `Do not use ${importString} to import from ${ownPackage} from code inside ${ownPackage}. ` +
+        ` Instead, use the ${pkg} alias or a relative import`;
+
+      const fix = (fixer) => fixer.replaceText(node.source, `'${pkg}${importPathWithSlash}'`);
+      context.report({ fix, node, message });
+    },
+  };
+};
+
+const ruleModule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: `Enforces spinnaker ES6 import conventions for package aliases`,
+    },
+    fixable: 'code',
+  },
+  create: rule,
+};
+
+export default ruleModule;

package/rules/import-from-npm-not-alias.spec.ts

@@ -0,0 +1,24 @@
+/* eslint-disable @spinnaker/import-sort */
+import '../utils/import-aliases.mock';
+import rule from './import-from-npm-not-alias';
+import ruleTester from '../utils/ruleTester';
+
+ruleTester.run('import-from-npm-not-alias', rule, {
+  valid: [
+    {
+      filename: '/root/spinnaker/deck/packages/amazon/package/amazon_source_file.ts',
+      code: `import { Anything } from 'amazon/otherpackage';`,
+    },
+  ],
+
+  invalid: [
+    {
+      filename: '/root/spinnaker/deck/packages/amazon/package/amazon_source_file.ts',
+      code: `import { Anything } from 'core/otherpackage';`,
+      output: `import { Anything } from '@spinnaker/core';`,
+      errors: [
+        'Do not use an alias to import from core from code inside amazon. Instead, use the npm package @spinnaker/core',
+      ],
+    },
+  ],
+});

package/rules/import-from-npm-not-alias.ts

@@ -0,0 +1,56 @@
+import type { Rule } from 'eslint';
+import type { ImportDeclaration } from 'estree';
+
+import { getAliasImport, getAllSpinnakerPackages, getSourceFileDetails } from '../utils/import-aliases';
+
+/**
+ * A group of rules that enforce spinnaker ES6 import alias conventions.
+ *
+ * Source code in a package (i.e., `amazon`) should not import from a different package using an alias (i.e., `core/`)
+ * Instead, it should import from `@spinnaker/core`
+ *
+ * @version 0.1.0
+ * @category conventions
+ */
+const rule = function (context: Rule.RuleContext) {
+  const sourceFile = context.getFilename();
+  const { modulesPath, ownPackage } = getSourceFileDetails(sourceFile);
+  if (!ownPackage) {
+    return {};
+  }
+  const allSpinnakerPackages = getAllSpinnakerPackages(modulesPath);
+
+  return {
+    ImportDeclaration: function (node: ImportDeclaration & Rule.NodeParentExtension) {
+      if (node.source.type !== 'Literal' || !node.source.value) {
+        return;
+      }
+
+      const importString = node.source.value as string;
+      const aliasImport = getAliasImport(allSpinnakerPackages, importString);
+
+      if (!aliasImport || aliasImport.pkg === ownPackage) {
+        return;
+      }
+      const { pkg } = aliasImport;
+      const message =
+        `Do not use an alias to import from ${pkg} from code inside ${ownPackage}.` +
+        ` Instead, use the npm package @spinnaker/${pkg}`;
+
+      const fix = (fixer) => fixer.replaceText(node.source, `'@spinnaker/${pkg}'`);
+      context.report({ fix, node, message });
+    },
+  };
+};
+
+const importAliasesRule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: `Enforces spinnaker ES6 import conventions for package aliases`,
+    },
+    fixable: 'code',
+  },
+  create: rule,
+};
+export default importAliasesRule;

package/rules/import-from-npm-not-relative.spec.ts

@@ -0,0 +1,22 @@
+import rule from './import-from-npm-not-relative';
+import ruleTester from '../utils/ruleTester';
+
+ruleTester.run('import-from-npm-not-relative', rule, {
+  valid: [
+    {
+      filename: '/root/spinnaker/deck/packages/amazon/package/amazon_source_file.ts',
+      code: `import { Anything } from '../othersubpackage/file2';`,
+    },
+  ],
+
+  invalid: [
+    {
+      filename: '/root/spinnaker/deck/packages/amazon/package/amazon_source_file.ts',
+      code: `import { Anything } from '../../core/subpackage/file2';`,
+      output: `import { Anything } from '@spinnaker/core';`,
+      errors: [
+        'Do not use a relative import to import from core from code inside amazon. Instead, use the npm package @spinnaker/core',
+      ],
+    },
+  ],
+});

package/rules/import-from-npm-not-relative.ts

@@ -0,0 +1,57 @@
+import type { Rule } from 'eslint';
+import type { ImportDeclaration } from 'estree';
+
+import { getRelativeImport, getSourceFileDetails } from '../utils/import-aliases';
+
+/**
+ * A group of rules that enforce spinnaker ES6 import alias conventions.
+ *
+ * Source code in a package (i.e., `amazon`) should not import from package (i.e., `core`) using a relative path.
+ * Instead, it should import from `@spinnaker/core`
+ *
+ * @version 0.1.0
+ * @category conventions
+ */
+const rule = function (context: Rule.RuleContext) {
+  const sourceFile = context.getFilename();
+  const { modulesPath, sourceDirectory, ownPackage } = getSourceFileDetails(sourceFile);
+  if (!ownPackage) {
+    return {};
+  }
+
+  return {
+    ImportDeclaration: function (node: ImportDeclaration) {
+      if (node.source.type !== 'Literal' || !node.source.value) {
+        return;
+      }
+
+      const importString = node.source.value as string;
+      const relativeImport = getRelativeImport(sourceDirectory, modulesPath, importString);
+
+      if (!relativeImport || relativeImport.pkg === ownPackage) {
+        return;
+      }
+
+      const { pkg } = relativeImport;
+      const message =
+        `Do not use a relative import to import from ${pkg} from code inside ${ownPackage}.` +
+        ` Instead, use the npm package @spinnaker/${pkg}`;
+
+      const fix = (fixer) => fixer.replaceText(node.source, `'@spinnaker/${pkg}'`);
+      context.report({ fix, node, message });
+    },
+  };
+};
+
+const ruleModule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: `Enforces spinnaker ES6 import conventions for package aliases`,
+    },
+    fixable: 'code',
+  },
+  create: rule,
+};
+
+export default ruleModule;

package/rules/import-from-presentation-not-core.spec.ts

@@ -0,0 +1,44 @@
+import rule from './import-from-presentation-not-core';
+import ruleTester from '../utils/ruleTester';
+const errorMessage = (moduleName) => `${moduleName} must be imported from @spinnaker/presentation`;
+
+ruleTester.run('import-from-presentation-not-core', rule, {
+  valid: [
+    { code: `import { Icon, Illustration } from '@spinnaker/presentation';` },
+    { code: `import { LabeledValueList } from '@spinnaker/core';` },
+    { code: `import { Application } from '@spinnaker/core';` },
+  ],
+  invalid: [
+    {
+      code: `
+      import { Icon, NotMigratedModule } from '@spinnaker/core';
+      import { Foo } from '@spinnaker/presentation';
+      `,
+      errors: [errorMessage('Icon')],
+      output: `
+      import {  NotMigratedModule } from '@spinnaker/core';
+      import { Foo, Icon } from '@spinnaker/presentation';
+      `,
+    },
+    {
+      code: `
+      import { Icon, NotMigratedModule } from '@spinnaker/core';
+      `,
+      errors: [errorMessage('Icon')],
+      output: `
+      import {  NotMigratedModule } from '@spinnaker/core';\nimport {Icon} from '@spinnaker/presentation';
+      `,
+    },
+    {
+      code: `
+      import React from 'react';
+      import { Icon } from '@spinnaker/core';
+      `,
+      errors: [errorMessage('Icon')],
+      output: `
+      import React from 'react';
+      \nimport {Icon} from '@spinnaker/presentation';
+      `,
+    },
+  ],
+});