Try to automatically create github releases when packages are updated

Author: ericallam

.changeset/config.json

@@ -1,11 +1,24 @@
 {
   "$schema": "https://unpkg.com/@changesets/config@2.2.0/schema.json",
-  "changelog": "@changesets/cli/changelog",
+  "changelog": [
+    "@remix-run/changelog-github",
+    {
+      "repo": "triggerdotdev/trigger.dev"
+    }
+  ],
   "commit": false,
-  "fixed": [["@trigger.dev/*"]],
+  "fixed": [
+    [
+      "@trigger.dev/*"
+    ]
+  ],
   "linked": [],
   "access": "public",
   "baseBranch": "main",
   "updateInternalDependencies": "patch",
-  "ignore": ["webapp", "emails", "@trigger.dev/database"]
-}
+  "ignore": [
+    "webapp",
+    "emails",
+    "@trigger.dev/database"
+  ]
+}

.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

.changeset/mighty-melons-vanish.md

@@ -0,0 +1,5 @@
+---
+"@trigger.dev/cli": patch
+---
+
+fix: init will no longer fail when outside of a git repo

.github/workflows/release.yml

@@ -71,7 +71,7 @@ jobs:
           commit: "chore: Update version for release"
           title: "chore: Update version for release"
           publish: pnpm run changeset:release
-          createGithubReleases: false
+          createGithubReleases: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package.json

@@ -64,6 +64,7 @@
   "packageManager": "pnpm@7.18.1",
   "dependencies": {
     "@changesets/cli": "^2.26.0",
+    "@remix-run/changelog-github": "^0.0.5",
     "node-fetch": "2.6.x"
   }
 }

packages/cli/src/commands/init.ts

@@ -253,9 +253,19 @@ const resolveOptionsWithPrompts = async (
 // Detects if there are any uncommitted git changes at path
 async function detectGitChanges(path: string): Promise<boolean> {
   const git = simpleGit(path);
-  const status = await git.status();
 
-  return status.files.length > 0;
+  try {
+    const isRepo = await git.checkIsRepo();
+
+    if (isRepo) {
+      // Check if there are uncommitted changes
+      const status = await git.status();
+      return status.files.length > 0;
+    }
+    return false;
+  } catch (error) {
+    return false;
+  }
 }
 
 async function detectTypescriptProject(path: string): Promise<boolean> {

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" },
+      ]
     }
   ]
 });