fix/TRI 1149/cover all duplicated cases (#398)

* feat: select node by property key name

* feat: get `IfStatement`s recursively

* refactor: make `getNodeBody` more readable

* refactor: enshorter rule code

* refactor: remove additional spaces

* Create lovely-teachers-taste.md

---------

Co-authored-by: Eric Allam <[email protected]>

Author: wesleymatosdev

.changeset/lovely-teachers-taste.md

@@ -0,0 +1,5 @@
+---
+"@trigger.dev/eslint-plugin": patch
+---
+
+Fixes #391, now handling jobs when using new Job instead of client.defineJob

packages/eslint-plugin/lib/rules/no-duplicated-task-keys.js

@@ -49,17 +49,21 @@ module.exports = {
       return property.name;
     }
 
-    const groupExpressionsByTask = (ExpressionStatements, map = new Map()) => ExpressionStatements.reduce((acc, { expression }) => {
-      const taskName = getTaskName(expression);
-      const taskKey = getKey(expression);
-
+    const groupByTaskKeyAndName = (acc, { taskKey, taskName }) => {
       if (acc.has(taskName)) {
         acc.get(taskName).push(taskKey);
       } else {
         acc.set(taskName, [taskKey]);
       }
 
       return acc;
+    }
+
+    const groupExpressionsByTask = (ExpressionStatements, map = new Map()) => ExpressionStatements.reduce((acc, { expression }) => {
+      const taskName = getTaskName(expression);
+      const taskKey = getKey(expression);
+
+      return groupByTaskKeyAndName(acc, { taskKey, taskName });
     }, map);
 
     const groupVariableDeclarationsByTask = VariableDeclarations => VariableDeclarations.reduce((acc, { declarations }) => {
@@ -70,30 +74,46 @@ module.exports = {
 
         const taskKey = getKey(declaration.init);
 
-        if (acc.has(taskName)) {
-          acc.get(taskName).push(taskKey);
-        } else {
-          acc.set(taskName, [taskKey]);
-        }
+        groupByTaskKeyAndName(acc, { taskKey, taskName });
       });
 
       return acc;
     }, new Map());
 
-    return {
-      "CallExpression[callee.property.name='defineJob'] ObjectExpression BlockStatement": (node) => {
-        const VariableDeclarations = node.body.filter((arg) => arg.type === 'VariableDeclaration');
+    const getInnerIfStatementBodies = (body) => body
+      .filter((arg) => arg.type === 'IfStatement')
+      .reduce((acc, arg) => {
+        const consequent = arg.consequent.body;
 
-        const grouped = groupVariableDeclarationsByTask(VariableDeclarations);
+        const AlternateBodies = getInnerIfStatementBodies(consequent);
+
+        const body = consequent.filter((arg) => arg.type !== 'IfStatement');
+
+        return acc.concat(body).concat(AlternateBodies);
+      }, [])
+
+    const getNodeBody = (node) => {
+      const body = node.value.body.body;
+
+      return body
+        .filter((arg) => arg.type !== 'IfStatement')
+        .concat(getInnerIfStatementBodies(body));
+    }
 
-        const ExpressionStatements = node.body.filter((arg) => arg.type === 'ExpressionStatement');
+    return {
+      "Property[key.name='run']": (node) => {
+        const body = getNodeBody(node);
 
+        const VariableDeclarations = body.filter((arg) => arg.type === 'VariableDeclaration');
+  
+        const grouped = groupVariableDeclarationsByTask(VariableDeclarations);
+  
+        const ExpressionStatements = body.filter((arg) => arg.type === 'ExpressionStatement');
+  
         // it'll be a map of taskName => [key1, key2, ...]
         const groupedByTask = groupExpressionsByTask(ExpressionStatements, grouped);
-
         groupedByTask.forEach((keys) => {
           const duplicated = keys.find((key, index) => keys.indexOf(key) !== index);
-
           if (duplicated) {
             context.report({
               node,

packages/eslint-plugin/tests/lib/rules/no-duplicated-task-keys.js

@@ -240,6 +240,86 @@ ruleTester.run("no-duplicated-task-keys", rule, {
         { message: "Task key 'Get Tag' is duplicated" },
         { message: "Task key 'Tag ' is duplicated" },
       ]
+    },
+    {
+      code: `import { Job, eventTrigger } from "@trigger.dev/sdk";
+      import { client } from "@/trigger";
+      
+      // your first job
+      new Job(client, {
+        id: "example-job",
+        name: "Example Job",
+        version: "0.0.1",
+        trigger: eventTrigger({
+          name: "example.event",
+        }),
+        run: async (payload, io, ctx) => {
+          await io.runTask("example.task", { name: "Task 1" }, async () => {});
+          await io.runTask("example.task", { name: "Task 2" }, async () => {});
+        },
+      });`,
+      errors: [
+        { message: "Task key 'example.task' is duplicated" },
+      ]
+    },
+    {
+      code: `import { Job, eventTrigger } from "@trigger.dev/sdk";
+      import { client } from "@/trigger";
+      
+      // your first job
+      new Job(client, {
+        id: "example-job",
+        name: "Example Job",
+        version: "0.0.1",
+        trigger: eventTrigger({
+          name: "example.event",
+        }),
+        run: async (payload, io, ctx) => {
+          await io.runTask("example.task", { name: "Task 1" }, async () => {});
+      
+          await io.anotherTask("different task", { name: "Task 1" }, async () => {});
+      
+          if (true) {
+            await io.runTask("example.task", { name: "Task 2" }, async () => {});
+      
+            if (true) {
+              await io.runTask("example.task", { name: "Task 3" }, async () => {});
+              await io.anotherTask("different task", { name: "Task 1" }, async () => {});
+            }
+          }
+        },
+      });`,
+      errors: [
+        { message: "Task key 'example.task' is duplicated" },
+        { message: "Task key 'different task' is duplicated" },
+      ]
+    },
+    {
+      code: `import { Job, eventTrigger } from "@trigger.dev/sdk";
+      import { client } from "@/trigger";
+      
+      // your first job
+      new Job(client, {
+        id: "example-job",
+        name: "Example Job",
+        version: "0.0.1",
+        trigger: eventTrigger({
+          name: "example.event",
+        }),
+        run: async (payload, io, ctx) => {
+          if (true) {
+            await io.runTask("example.task", { name: "Task 1" }, async () => {});
+      
+            if (true) {
+              await io.runTask("example.task", { name: "Task 2" }, async () => {});
+              await io.anotherTask("different task", { name: "Task 1" }, async () => {});
+            }
+          }
+        },
+      });`,
+      errors: [
+        { message: "Task key 'example.task' is duplicated" },
+      ]
     }
   ]
 });