fix: check namespace imports

Author: JasonWeinzierl

src/rules/no-sharereplay-before-takeuntil.ts

@@ -16,56 +16,68 @@ export const noSharereplayBeforeTakeuntilRule = ruleCreator({
   },
   name: 'no-sharereplay-before-takeuntil',
   create: (context) => {
-    return {
-      'CallExpression[callee.name="shareReplay"]': (node: es.CallExpression) => {
-        const pipeCallExpression = node.parent as es.CallExpression;
-        if (
-          !pipeCallExpression.arguments
-          || !isMemberExpression(pipeCallExpression.callee)
-          || !isIdentifier(pipeCallExpression.callee.property)
-          || pipeCallExpression.callee.property.name !== 'pipe'
-        ) {
-          return;
-        }
+    function checkCallExpression(node: es.CallExpression) {
+      const pipeCallExpression = node.parent as es.CallExpression;
+      if (
+        !pipeCallExpression.arguments
+        || !isMemberExpression(pipeCallExpression.callee)
+        || !isIdentifier(pipeCallExpression.callee.property)
+        || pipeCallExpression.callee.property.name !== 'pipe'
+      ) {
+        return;
+      }
+
+      const takeUntilIndex = pipeCallExpression.arguments.findIndex(arg =>
+        isCallExpression(arg)
+        && (
+          (isIdentifier(arg.callee)
+            && arg.callee.name === 'takeUntil')
+          || (isMemberExpression(arg.callee)
+            && isIdentifier(arg.callee.property)
+            && arg.callee.property.name === 'takeUntil')
+        ),
+      );
 
-        const takeUntilIndex = pipeCallExpression.arguments.findIndex(arg =>
-          isCallExpression(arg)
-          && isIdentifier(arg.callee)
-          && arg.callee.name === 'takeUntil',
-        );
+      if (takeUntilIndex === -1) {
+        return;
+      }
 
-        if (takeUntilIndex === -1) {
-          return;
-        }
+      const shareReplayConfig = node.arguments[0];
+      if (
+        !shareReplayConfig
+        || !isObjectExpression(shareReplayConfig)
+      ) {
+        // refCount defaults to false if no config is provided.
+        context.report({
+          messageId: 'forbidden',
+          node: node.callee,
+        });
+        return;
+      }
 
-        const shareReplayConfig = node.arguments[0];
-        if (
-          !shareReplayConfig
-          || !isObjectExpression(shareReplayConfig)
-        ) {
-          // refCount defaults to false if no config is provided.
-          context.report({
-            messageId: 'forbidden',
-            node: node.callee,
-          });
-          return;
-        }
+      const refCountElement = shareReplayConfig.properties
+        .filter(isProperty)
+        .find(prop =>
+          isIdentifier(prop.key)
+          && prop.key.name === 'refCount');
+      if (
+        !refCountElement
+        || (isLiteral(refCountElement.value)
+          && refCountElement.value.value === false)
+      ) {
+        context.report({
+          messageId: 'forbidden',
+          node: node.callee,
+        });
+      }
+    }
 
-        const refCountElement = shareReplayConfig.properties
-          .filter(isProperty)
-          .find(prop =>
-            isIdentifier(prop.key)
-            && prop.key.name === 'refCount');
-        if (
-          !refCountElement
-          || (isLiteral(refCountElement.value)
-            && refCountElement.value.value === false)
-        ) {
-          context.report({
-            messageId: 'forbidden',
-            node: node.callee,
-          });
-        }
+    return {
+      'CallExpression[callee.name="shareReplay"]': (node: es.CallExpression) => {
+        checkCallExpression(node);
+      },
+      'CallExpression[callee.property.name="shareReplay"]': (node: es.CallExpression) => {
+        checkCallExpression(node);
       },
     };
   },

tests/rules/no-sharereplay-before-takeuntil.test.ts

@@ -12,9 +12,38 @@ ruleTester({ types: false }).run('no-sharereplay-before-takeuntil', noSharerepla
       const a = of("a");
       const b = of("b");
 
+      a.pipe(shareReplay({ refCount: true }), takeUntil(b));
+    `,
+    stripIndent`
+      // with refCount true as const
+      import { of, takeUntil, shareReplay } from "rxjs";
+
+      const a = of("a");
+      const b = of("b");
+
       const t = true as const;
       a.pipe(shareReplay({ refCount: t }), takeUntil(b));
     `,
+    stripIndent`
+      // refCount variable not supported
+      import { of, takeUntil, shareReplay } from "rxjs";
+
+      const a = of("a");
+      const b = of("b");
+
+      const t = false;
+      a.pipe(shareReplay({ refCount: t }), takeUntil(b));
+    `,
+    stripIndent`
+      // composed observables not supported
+      import { of, takeUntil, shareReplay } from "rxjs";
+
+      const a = of("a");
+      const b = of("b");
+
+      const sr = shareReplay({ refCount: false });
+      a.pipe(sr, takeUntil(b));
+    `,
     stripIndent`
       // unrelated
       import { of, takeUntil, toArray } from "rxjs";
@@ -50,5 +79,29 @@ ruleTester({ types: false }).run('no-sharereplay-before-takeuntil', noSharerepla
                ~~~~~~~~~~~ [forbidden]
       `,
     ),
+    fromFixture(
+      stripIndent`
+        // with operators in between
+        import { of, takeUntil, shareReplay, map, filter } from "rxjs";
+
+        const a = of("a");
+        const b = of("b");
+
+        a.pipe(shareReplay(), map(x => x), filter(x => !!x), takeUntil(b));
+               ~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // namespace import
+        import * as Rx from "rxjs";
+
+        const a = Rx.of("a");
+        const b = Rx.of("b");
+
+        a.pipe(Rx.shareReplay(), Rx.takeUntil(b));
+               ~~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
   ],
 });