feat(no-import-operators): new rule to ban rxjs/operators imports

Author: JasonWeinzierl

README.md

@@ -88,6 +88,7 @@ The package includes the following rules.
 | [no-ignored-subscription](docs/rules/no-ignored-subscription.md)       | Disallow ignoring the subscription returned by `subscribe`.                                               |    |    |    | 💭 |    |
 | [no-ignored-takewhile-value](docs/rules/no-ignored-takewhile-value.md) | Disallow ignoring the value within `takeWhile`.                                                           | ✅  |    |    |    |    |
 | [no-implicit-any-catch](docs/rules/no-implicit-any-catch.md)           | Disallow implicit `any` error parameters in `catchError` operators.                                       | ✅  | 🔧 | 💡 | 💭 |    |
+| [no-import-operators](docs/rules/no-import-operators.md)               | Disallow importing operators from `rxjs/operators`.                                                       |    |    |    |    |    |
 | [no-index](docs/rules/no-index.md)                                     | Disallow importing index modules.                                                                         | ✅  |    |    |    |    |
 | [no-internal](docs/rules/no-internal.md)                               | Disallow importing internal modules.                                                                      | ✅  | 🔧 | 💡 |    |    |
 | [no-nested-subscribe](docs/rules/no-nested-subscribe.md)               | Disallow calling `subscribe` within a `subscribe` callback.                                               | ✅  |    |    | 💭 |    |

docs/rules/no-import-operators.md

@@ -0,0 +1,26 @@
+# Disallow importing operators from `rxjs/operators` (`rxjs-x/no-import-operators`)
+
+<!-- end auto-generated rule header -->
+
+This rule prevents importing from the `rxjs/operators` export site.
+Most operators were moved to the `rxjs` export site in RxJS v7.2.0
+(excepting a couple of old and deprecated operators).
+The `rxjs/operators` export site has since been deprecated and will be removed in a future major version.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { map } from 'rxjs/operators';
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { map } from 'rxjs';
+```
+
+## Further reading
+
+- [Importing instructions](https://rxjs.dev/guide/importing)

src/index.ts

@@ -24,6 +24,7 @@ import { noIgnoredSubscribeRule } from './rules/no-ignored-subscribe';
 import { noIgnoredSubscriptionRule } from './rules/no-ignored-subscription';
 import { noIgnoredTakewhileValueRule } from './rules/no-ignored-takewhile-value';
 import { noImplicitAnyCatchRule } from './rules/no-implicit-any-catch';
+import { noImportOperatorsRule } from './rules/no-import-operators';
 import { noIndexRule } from './rules/no-index';
 import { noInternalRule } from './rules/no-internal';
 import { noNestedSubscribeRule } from './rules/no-nested-subscribe';
@@ -70,6 +71,7 @@ const plugin = {
     'no-ignored-subscription': noIgnoredSubscriptionRule,
     'no-ignored-takewhile-value': noIgnoredTakewhileValueRule,
     'no-implicit-any-catch': noImplicitAnyCatchRule,
+    'no-import-operators': noImportOperatorsRule,
     'no-index': noIndexRule,
     'no-internal': noInternalRule,
     'no-nested-subscribe': noNestedSubscribeRule,

src/rules/no-import-operators.ts

@@ -0,0 +1,45 @@
+import { TSESTree as es } from '@typescript-eslint/utils';
+import { ruleCreator } from '../utils';
+
+export const noImportOperatorsRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: 'Disallow importing operators from `rxjs/operators`.',
+    },
+    messages: {
+      forbidden: 'RxJS imports from `rxjs/operators` are forbidden.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-import-operators',
+  create: (context) => {
+    return {
+      'ImportDeclaration Literal[value="rxjs/operators"]': (node: es.Literal) => {
+        context.report({
+          messageId: 'forbidden',
+          node,
+        });
+      },
+      'ImportExpression Literal[value="rxjs/operators"]': (node: es.Literal) => {
+        context.report({
+          messageId: 'forbidden',
+          node,
+        });
+      },
+      'ExportNamedDeclaration Literal[value="rxjs/operators"]': (node: es.Literal) => {
+        context.report({
+          messageId: 'forbidden',
+          node,
+        });
+      },
+      'ExportAllDeclaration Literal[value="rxjs/operators"]': (node: es.Literal) => {
+        context.report({
+          messageId: 'forbidden',
+          node,
+        });
+      },
+    };
+  },
+});

tests/rules/no-import-operators.test.ts

@@ -0,0 +1,82 @@
+import { stripIndent } from 'common-tags';
+import { noImportOperatorsRule } from '../../src/rules/no-import-operators';
+import { fromFixture } from '../etc';
+import { ruleTester } from '../rule-tester';
+
+ruleTester({ types: false }).run('no-import-operators', noImportOperatorsRule, {
+  valid: [
+    stripIndent`
+      // import declaration named
+      import { concat } from "rxjs";
+      import { concat } from 'rxjs';
+    `,
+    stripIndent`
+      // import declaration namespace
+      import * as Rx from "rxjs";
+    `,
+    stripIndent`
+      // import expression
+      const { concat } = await import("rxjs");
+    `,
+    stripIndent`
+      // import expression with identifier is not supported
+      const path = "rxjs/operators";
+      const { concat } = await import(path);
+    `,
+    stripIndent`
+      // export named
+      export { concat } from "rxjs";
+    `,
+    stripIndent`
+      // export all
+      export * from "rxjs";
+    `,
+    stripIndent`
+      // unrelated import
+      import { ajax } from "rxjs/ajax";
+      import { fromFetch } from "rxjs/fetch";
+      import { TestScheduler } from "rxjs/testing";
+      import { webSocket } from "rxjs/webSocket";
+      import * as prefixedPackage from "rxjs-prefixed-package";
+    `,
+  ],
+  invalid: [
+    fromFixture(
+      stripIndent`
+        // import declaration named
+        import { concat } from "rxjs/operators";
+                               ~~~~~~~~~~~~~~~~ [forbidden]
+        import { concat } from 'rxjs/operators';
+                               ~~~~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // import declaration namespace
+        import * as RxOperators from "rxjs/operators";
+                                     ~~~~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // import expression
+        const { concat } = await import("rxjs/operators");
+                                        ~~~~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // export named
+        export { concat } from "rxjs/operators";
+                               ~~~~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // export all
+        export * from "rxjs/operators";
+                      ~~~~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+  ],
+});