From b4061f2ae71f21889adcf061928e2e77c436f0ed Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Sat, 13 Apr 2024 11:29:26 +0100
Subject: [PATCH 01/11] fix dev dependecy resumes

---
 .../v3/services/batchTriggerTask.server.ts    | 22 +++++++++++++++++++
 .../app/v3/services/triggerTask.server.ts     | 22 +++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/apps/webapp/app/v3/services/batchTriggerTask.server.ts b/apps/webapp/app/v3/services/batchTriggerTask.server.ts
index ac286e8cbf7..5ff8e4a1906 100644
--- a/apps/webapp/app/v3/services/batchTriggerTask.server.ts
+++ b/apps/webapp/app/v3/services/batchTriggerTask.server.ts
@@ -54,6 +54,28 @@ export class BatchTriggerTaskService extends BaseService {
           })
         : undefined;
 
+      if (dependentAttempt && environment.type === "DEVELOPMENT") {
+        // The dev worker handles dependency resumes and attempt completions in parallel, so we need to clear any existing ones here to prevent race conditions
+        const existingBatch = await this._prisma.batchTaskRun.findUnique({
+          where: {
+            dependentTaskAttemptId: dependentAttempt.id,
+          },
+        });
+
+        if (existingBatch) {
+          await this._prisma.batchTaskRun.update({
+            where: {
+              id: existingBatch.id,
+            },
+            data: {
+              dependentTaskAttempt: {
+                disconnect: true,
+              },
+            },
+          });
+        }
+      }
+
       const batch = await this._prisma.batchTaskRun.create({
         data: {
           friendlyId: generateFriendlyId("batch"),
diff --git a/apps/webapp/app/v3/services/triggerTask.server.ts b/apps/webapp/app/v3/services/triggerTask.server.ts
index fc976314bdf..d1b62a1bda1 100644
--- a/apps/webapp/app/v3/services/triggerTask.server.ts
+++ b/apps/webapp/app/v3/services/triggerTask.server.ts
@@ -147,6 +147,28 @@ export class TriggerTaskService extends BaseService {
               });
 
               if (dependentAttempt) {
+                if (environment.type === "DEVELOPMENT") {
+                  // The dev worker handles dependency resumes and attempt completions in parallel, so we need to clear any existing ones here to prevent race conditions
+                  const existingDependency = await tx.taskRunDependency.findUnique({
+                    where: {
+                      dependentAttemptId: dependentAttempt.id,
+                    },
+                  });
+
+                  if (existingDependency) {
+                    await tx.taskRunDependency.update({
+                      where: {
+                        id: existingDependency.id,
+                      },
+                      data: {
+                        dependentAttempt: {
+                          disconnect: true,
+                        },
+                      },
+                    });
+                  }
+                }
+
                 await tx.taskRunDependency.create({
                   data: {
                     taskRunId: taskRun.id,

From 6cc8d667545cb43108c3432a2295d2b0470290a1 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Sat, 13 Apr 2024 11:30:55 +0100
Subject: [PATCH 02/11] add catalog entry with multiple trigger waits

---
 references/v3-catalog/src/trigger/subtasks.ts | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/references/v3-catalog/src/trigger/subtasks.ts b/references/v3-catalog/src/trigger/subtasks.ts
index a1e6a742d4e..73d55cc330f 100644
--- a/references/v3-catalog/src/trigger/subtasks.ts
+++ b/references/v3-catalog/src/trigger/subtasks.ts
@@ -114,3 +114,28 @@ export const subtasksWithRetries = task({
     };
   },
 });
+
+export const multipleTriggerWaits = task({
+  id: "multiple-trigger-waits",
+  run: async ({ message = "test" }: { message?: string }) => {
+    await simpleChildTask.triggerAndWait({ payload: { message: `${message} - 1.a` } });
+    await simpleChildTask.triggerAndWait({ payload: { message: `${message} - 2.a` } });
+
+    await simpleChildTask.batchTriggerAndWait({
+      items: [
+        { payload: { message: `${message} - 3.a` } },
+        { payload: { message: `${message} - 3.b` } },
+      ],
+    });
+    await simpleChildTask.batchTriggerAndWait({
+      items: [
+        { payload: { message: `${message} - 4.a` } },
+        { payload: { message: `${message} - 4.b` } },
+      ],
+    });
+
+    return {
+      hello: "world",
+    };
+  },
+});

From a2a9d1f6056238bc7cc5f34feffdc2d325843241 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Sat, 13 Apr 2024 11:31:24 +0100
Subject: [PATCH 03/11] update docker provider lifecycle command

---
 apps/docker-provider/src/index.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/apps/docker-provider/src/index.ts b/apps/docker-provider/src/index.ts
index 7728449dac3..f1f945853c4 100644
--- a/apps/docker-provider/src/index.ts
+++ b/apps/docker-provider/src/index.ts
@@ -257,6 +257,7 @@ class DockerTaskOperations implements TaskOperations {
       return await execa("docker", [
         "exec",
         containerName,
+        "busybox",
         "wget",
         "-q",
         "-O-",

From c92c8da7ed705bae4d9f19947e1976ac78fe67a4 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Sat, 13 Apr 2024 11:31:48 +0100
Subject: [PATCH 04/11] switch to x for clearing run filters

---
 apps/webapp/app/components/runs/v3/RunFilters.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/apps/webapp/app/components/runs/v3/RunFilters.tsx b/apps/webapp/app/components/runs/v3/RunFilters.tsx
index 821e291fd50..8ef80801e72 100644
--- a/apps/webapp/app/components/runs/v3/RunFilters.tsx
+++ b/apps/webapp/app/components/runs/v3/RunFilters.tsx
@@ -1,4 +1,4 @@
-import { TrashIcon } from "@heroicons/react/20/solid";
+import { XMarkIcon } from "@heroicons/react/20/solid";
 import { useNavigate } from "@remix-run/react";
 import type { TaskRunStatus as TaskRunStatusType } from "@trigger.dev/database";
 import { RuntimeEnvironment, TaskRunAttemptStatus, TaskRunStatus } from "@trigger.dev/database";
@@ -247,7 +247,7 @@ export function RunsFilters({ possibleEnvironments, possibleTasks }: RunFiltersP
 
       <TimeFrameFilter from={from} to={to} onRangeChanged={handleTimeFrameChange} />
 
-      <Button variant="minimal/small" onClick={() => clearFilters()} LeadingIcon={TrashIcon} />
+      <Button variant="minimal/small" onClick={() => clearFilters()} LeadingIcon={XMarkIcon} />
     </div>
   );
 }

From 99008b7d6f6d84f883bf89cd8053163072a9ba65 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Mon, 15 Apr 2024 14:29:53 +0100
Subject: [PATCH 05/11] Revert "fix dev dependecy resumes"

This reverts commit b4061f2ae71f21889adcf061928e2e77c436f0ed.
---
 .../v3/services/batchTriggerTask.server.ts    | 22 -------------------
 .../app/v3/services/triggerTask.server.ts     | 22 -------------------
 2 files changed, 44 deletions(-)

diff --git a/apps/webapp/app/v3/services/batchTriggerTask.server.ts b/apps/webapp/app/v3/services/batchTriggerTask.server.ts
index 5ff8e4a1906..ac286e8cbf7 100644
--- a/apps/webapp/app/v3/services/batchTriggerTask.server.ts
+++ b/apps/webapp/app/v3/services/batchTriggerTask.server.ts
@@ -54,28 +54,6 @@ export class BatchTriggerTaskService extends BaseService {
           })
         : undefined;
 
-      if (dependentAttempt && environment.type === "DEVELOPMENT") {
-        // The dev worker handles dependency resumes and attempt completions in parallel, so we need to clear any existing ones here to prevent race conditions
-        const existingBatch = await this._prisma.batchTaskRun.findUnique({
-          where: {
-            dependentTaskAttemptId: dependentAttempt.id,
-          },
-        });
-
-        if (existingBatch) {
-          await this._prisma.batchTaskRun.update({
-            where: {
-              id: existingBatch.id,
-            },
-            data: {
-              dependentTaskAttempt: {
-                disconnect: true,
-              },
-            },
-          });
-        }
-      }
-
       const batch = await this._prisma.batchTaskRun.create({
         data: {
           friendlyId: generateFriendlyId("batch"),
diff --git a/apps/webapp/app/v3/services/triggerTask.server.ts b/apps/webapp/app/v3/services/triggerTask.server.ts
index d1b62a1bda1..fc976314bdf 100644
--- a/apps/webapp/app/v3/services/triggerTask.server.ts
+++ b/apps/webapp/app/v3/services/triggerTask.server.ts
@@ -147,28 +147,6 @@ export class TriggerTaskService extends BaseService {
               });
 
               if (dependentAttempt) {
-                if (environment.type === "DEVELOPMENT") {
-                  // The dev worker handles dependency resumes and attempt completions in parallel, so we need to clear any existing ones here to prevent race conditions
-                  const existingDependency = await tx.taskRunDependency.findUnique({
-                    where: {
-                      dependentAttemptId: dependentAttempt.id,
-                    },
-                  });
-
-                  if (existingDependency) {
-                    await tx.taskRunDependency.update({
-                      where: {
-                        id: existingDependency.id,
-                      },
-                      data: {
-                        dependentAttempt: {
-                          disconnect: true,
-                        },
-                      },
-                    });
-                  }
-                }
-
                 await tx.taskRunDependency.create({
                   data: {
                     taskRunId: taskRun.id,

From 8cc207e4171dfe9f3733edb59b300c8ca29baa52 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Mon, 15 Apr 2024 16:37:22 +0100
Subject: [PATCH 06/11] fix dependency resumes, properly this time

---
 .../app/v3/services/resumeAttempt.server.ts   | 235 +++++++++---------
 .../migration.sql                             |   2 +
 .../migration.sql                             |   2 +
 packages/database/prisma/schema.prisma        |  10 +-
 4 files changed, 128 insertions(+), 121 deletions(-)
 create mode 100644 packages/database/prisma/migrations/20240415135132_make_attempt_dependencies_an_array/migration.sql
 create mode 100644 packages/database/prisma/migrations/20240415143325_remove_attempt_unique_constraint_from_batch_runs/migration.sql

diff --git a/apps/webapp/app/v3/services/resumeAttempt.server.ts b/apps/webapp/app/v3/services/resumeAttempt.server.ts
index 1e47e7d7b7a..4e4affe948f 100644
--- a/apps/webapp/app/v3/services/resumeAttempt.server.ts
+++ b/apps/webapp/app/v3/services/resumeAttempt.server.ts
@@ -4,12 +4,13 @@ import {
   TaskRunExecution,
   TaskRunExecutionResult,
 } from "@trigger.dev/core/v3";
-import { $transaction } from "~/db.server";
+import { $transaction, PrismaClientOrTransaction } from "~/db.server";
 import { logger } from "~/services/logger.server";
 import { marqs } from "~/v3/marqs/index.server";
 import { socketIo } from "../handleSocketIo.server";
 import { sharedQueueTasks } from "../marqs/sharedQueueConsumer.server";
 import { BaseService } from "./baseService.server";
+import { TaskRunAttempt } from "@trigger.dev/database";
 
 export class ResumeAttemptService extends BaseService {
   public async call(
@@ -24,7 +25,7 @@ export class ResumeAttemptService extends BaseService {
         },
         include: {
           taskRun: true,
-          taskRunDependency: {
+          dependencies: {
             include: {
               taskRun: {
                 include: {
@@ -40,8 +41,12 @@ export class ResumeAttemptService extends BaseService {
                 },
               },
             },
+            orderBy: {
+              createdAt: "desc",
+            },
+            take: 1,
           },
-          batchTaskRunDependency: {
+          batchDependencies: {
             include: {
               items: {
                 include: {
@@ -61,6 +66,10 @@ export class ResumeAttemptService extends BaseService {
                 },
               },
             },
+            orderBy: {
+              createdAt: "desc",
+            },
+            take: 1,
           },
         },
       });
@@ -78,6 +87,8 @@ export class ResumeAttemptService extends BaseService {
         return;
       }
 
+      let completedAttemptIds: string[] = [];
+
       switch (params.type) {
         case "WAIT_FOR_DURATION": {
           logger.error(
@@ -93,12 +104,10 @@ export class ResumeAttemptService extends BaseService {
           });
           break;
         }
-        case "WAIT_FOR_TASK":
-        case "WAIT_FOR_BATCH": {
-          let completedAttemptIds: string[] = [];
-
-          if (attempt.taskRunDependency) {
-            const dependentAttempt = attempt.taskRunDependency.taskRun.attempts[0];
+        case "WAIT_FOR_TASK": {
+          if (attempt.dependencies.length) {
+            // We only care about the latest dependency
+            const dependentAttempt = attempt.dependencies[0].taskRun.attempts[0];
 
             if (!dependentAttempt) {
               logger.error("No dependent attempt", { attemptId: attempt.id });
@@ -106,19 +115,16 @@ export class ResumeAttemptService extends BaseService {
             }
 
             completedAttemptIds = [dependentAttempt.id];
-
-            await tx.taskRunAttempt.update({
-              where: {
-                id: attempt.id,
-              },
-              data: {
-                taskRunDependency: {
-                  disconnect: true,
-                },
-              },
-            });
-          } else if (attempt.batchTaskRunDependency) {
-            const dependentBatchItems = attempt.batchTaskRunDependency.items;
+          } else {
+            logger.error("No task dependency", { attemptId: attempt.id });
+            return;
+          }
+          break;
+        }
+        case "WAIT_FOR_BATCH": {
+          if (attempt.batchDependencies) {
+            // We only care about the latest batch dependency
+            const dependentBatchItems = attempt.batchDependencies[0].items;
 
             if (!dependentBatchItems) {
               logger.error("No dependent batch items", { attemptId: attempt.id });
@@ -126,115 +132,112 @@ export class ResumeAttemptService extends BaseService {
             }
 
             completedAttemptIds = dependentBatchItems.map((item) => item.taskRun.attempts[0]?.id);
-
-            await tx.taskRunAttempt.update({
-              where: {
-                id: attempt.id,
-              },
-              data: {
-                batchTaskRunDependency: {
-                  disconnect: true,
-                },
-              },
-            });
           } else {
-            logger.error("No dependencies", { attemptId: attempt.id });
-            return;
-          }
-
-          if (completedAttemptIds.length === 0) {
-            logger.error("No completed attempt IDs", { attemptId: attempt.id });
+            logger.error("No batch dependency", { attemptId: attempt.id });
             return;
           }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
 
-          const completions: TaskRunExecutionResult[] = [];
-          const executions: TaskRunExecution[] = [];
+      await this.#handleDependencyResume(attempt, completedAttemptIds, tx);
+    });
+  }
 
-          for (const completedAttemptId of completedAttemptIds) {
-            const completedAttempt = await tx.taskRunAttempt.findUnique({
-              where: {
-                id: completedAttemptId,
-                taskRun: {
-                  lockedAt: {
-                    not: null,
-                  },
-                  lockedById: {
-                    not: null,
-                  },
-                },
-              },
-            });
-
-            if (!completedAttempt) {
-              logger.error("Completed attempt not found", {
-                attemptId: attempt.id,
-                completedAttemptId,
-              });
-              await marqs?.acknowledgeMessage(attempt.taskRunId);
-              return;
-            }
+  async #handleDependencyResume(
+    attempt: TaskRunAttempt,
+    completedAttemptIds: string[],
+    tx: PrismaClientOrTransaction
+  ) {
+    if (completedAttemptIds.length === 0) {
+      logger.error("No completed attempt IDs", { attemptId: attempt.id });
+      return;
+    }
+
+    const completions: TaskRunExecutionResult[] = [];
+    const executions: TaskRunExecution[] = [];
+
+    for (const completedAttemptId of completedAttemptIds) {
+      const completedAttempt = await tx.taskRunAttempt.findUnique({
+        where: {
+          id: completedAttemptId,
+          taskRun: {
+            lockedAt: {
+              not: null,
+            },
+            lockedById: {
+              not: null,
+            },
+          },
+        },
+      });
 
-            const completion = await sharedQueueTasks.getCompletionPayloadFromAttempt(
-              completedAttempt.id
-            );
+      if (!completedAttempt) {
+        logger.error("Completed attempt not found", {
+          attemptId: attempt.id,
+          completedAttemptId,
+        });
+        await marqs?.acknowledgeMessage(attempt.taskRunId);
+        return;
+      }
 
-            if (!completion) {
-              logger.error("Failed to get completion payload", {
-                attemptId: attempt.id,
-                completedAttemptId,
-              });
-              await marqs?.acknowledgeMessage(attempt.taskRunId);
-              return;
-            }
+      const completion = await sharedQueueTasks.getCompletionPayloadFromAttempt(
+        completedAttempt.id
+      );
 
-            completions.push(completion);
+      if (!completion) {
+        logger.error("Failed to get completion payload", {
+          attemptId: attempt.id,
+          completedAttemptId,
+        });
+        await marqs?.acknowledgeMessage(attempt.taskRunId);
+        return;
+      }
 
-            const executionPayload = await sharedQueueTasks.getExecutionPayloadFromAttempt(
-              completedAttempt.id
-            );
+      completions.push(completion);
 
-            if (!executionPayload) {
-              logger.error("Failed to get execution payload", {
-                attemptId: attempt.id,
-                completedAttemptId,
-              });
-              await marqs?.acknowledgeMessage(attempt.taskRunId);
-              return;
-            }
+      const executionPayload = await sharedQueueTasks.getExecutionPayloadFromAttempt(
+        completedAttempt.id
+      );
 
-            executions.push(executionPayload.execution);
-          }
+      if (!executionPayload) {
+        logger.error("Failed to get execution payload", {
+          attemptId: attempt.id,
+          completedAttemptId,
+        });
+        await marqs?.acknowledgeMessage(attempt.taskRunId);
+        return;
+      }
 
-          const updated = await tx.taskRunAttempt.update({
-            where: {
-              id: attempt.id,
-            },
+      executions.push(executionPayload.execution);
+    }
+
+    const updated = await tx.taskRunAttempt.update({
+      where: {
+        id: attempt.id,
+      },
+      data: {
+        status: "EXECUTING",
+        taskRun: {
+          update: {
             data: {
-              status: "EXECUTING",
-              taskRun: {
-                update: {
-                  data: {
-                    status: attempt.number > 1 ? "RETRYING_AFTER_FAILURE" : "EXECUTING",
-                  },
-                },
-              },
+              status: attempt.number > 1 ? "RETRYING_AFTER_FAILURE" : "EXECUTING",
             },
-          });
+          },
+        },
+      },
+    });
 
-          socketIo.coordinatorNamespace.emit("RESUME_AFTER_DEPENDENCY", {
-            version: "v1",
-            runId: attempt.taskRunId,
-            attemptId: attempt.id,
-            attemptFriendlyId: attempt.friendlyId,
-            completions,
-            executions,
-          });
-          break;
-        }
-        default: {
-          break;
-        }
-      }
+    socketIo.coordinatorNamespace.emit("RESUME_AFTER_DEPENDENCY", {
+      version: "v1",
+      runId: attempt.taskRunId,
+      attemptId: attempt.id,
+      attemptFriendlyId: attempt.friendlyId,
+      completions,
+      executions,
     });
   }
 }
diff --git a/packages/database/prisma/migrations/20240415135132_make_attempt_dependencies_an_array/migration.sql b/packages/database/prisma/migrations/20240415135132_make_attempt_dependencies_an_array/migration.sql
new file mode 100644
index 00000000000..f3117c4fafe
--- /dev/null
+++ b/packages/database/prisma/migrations/20240415135132_make_attempt_dependencies_an_array/migration.sql
@@ -0,0 +1,2 @@
+-- DropIndex
+DROP INDEX "TaskRunDependency_dependentAttemptId_key";
diff --git a/packages/database/prisma/migrations/20240415143325_remove_attempt_unique_constraint_from_batch_runs/migration.sql b/packages/database/prisma/migrations/20240415143325_remove_attempt_unique_constraint_from_batch_runs/migration.sql
new file mode 100644
index 00000000000..e1365003815
--- /dev/null
+++ b/packages/database/prisma/migrations/20240415143325_remove_attempt_unique_constraint_from_batch_runs/migration.sql
@@ -0,0 +1,2 @@
+-- DropIndex
+DROP INDEX "BatchTaskRun_dependentTaskAttemptId_key";
diff --git a/packages/database/prisma/schema.prisma b/packages/database/prisma/schema.prisma
index 74c0e93fe89..7610ea87471 100644
--- a/packages/database/prisma/schema.prisma
+++ b/packages/database/prisma/schema.prisma
@@ -1667,8 +1667,8 @@ model TaskRunDependency {
   checkpointEventId String?                 @unique
 
   /// An attempt that is dependent on this task run. 
-  dependentAttempt   TaskRunAttempt? @relation("dependentAttempt", fields: [dependentAttemptId], references: [id])
-  dependentAttemptId String?         @unique
+  dependentAttempt   TaskRunAttempt? @relation(fields: [dependentAttemptId], references: [id])
+  dependentAttemptId String?
 
   /// A batch run that is dependent on this task run
   dependentBatchRun   BatchTaskRun? @relation("dependentBatchRun", fields: [dependentBatchRunId], references: [id])
@@ -1732,8 +1732,8 @@ model TaskRunAttempt {
   output     String?
   outputType String  @default("application/json")
 
-  taskRunDependency      TaskRunDependency? @relation("dependentAttempt")
-  batchTaskRunDependency BatchTaskRun?
+  dependencies      TaskRunDependency[]
+  batchDependencies BatchTaskRun[]
 
   checkpoints            Checkpoint[]
   batchTaskRunItems      BatchTaskRunItem[]
@@ -1904,7 +1904,7 @@ model BatchTaskRun {
   runtimeEnvironmentId String
 
   dependentTaskAttempt   TaskRunAttempt? @relation(fields: [dependentTaskAttemptId], references: [id], onDelete: Cascade, onUpdate: Cascade)
-  dependentTaskAttemptId String?         @unique
+  dependentTaskAttemptId String?
 
   items           BatchTaskRunItem[]
   runDependencies TaskRunDependency[] @relation("dependentBatchRun")

From 8f434cbcd5c10afdd8ebf4aea15056e619992b59 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Mon, 15 Apr 2024 17:29:54 +0100
Subject: [PATCH 07/11] add catalog entry for dependency waits in loops

---
 references/v3-catalog/src/trigger/subtasks.ts | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/references/v3-catalog/src/trigger/subtasks.ts b/references/v3-catalog/src/trigger/subtasks.ts
index 73d55cc330f..5dd618e3eac 100644
--- a/references/v3-catalog/src/trigger/subtasks.ts
+++ b/references/v3-catalog/src/trigger/subtasks.ts
@@ -139,3 +139,29 @@ export const multipleTriggerWaits = task({
     };
   },
 });
+
+export const triggerAndWaitLoops = task({
+  id: "trigger-wait-loops",
+  run: async ({ message = "test" }: { message?: string }) => {
+    for (let i = 0; i < 2; i++) {
+      await simpleChildTask.triggerAndWait({ payload: { message: `${message} - ${i}` } });
+    }
+
+    for (let i = 0; i < 2; i++) {
+      await simpleChildTask.batchTriggerAndWait({
+        items: [
+          { payload: { message: `${message} - ${i}.a` } },
+          { payload: { message: `${message} - ${i}.b` } },
+        ],
+        // batchOptions: { maxConcurrency: 1 },
+      });
+    }
+
+    // Don't do this!
+    // await Promise.all(
+    //   [{ message: `${message} - 1` }, { message: `${message} - 2` }].map((payload) =>
+    //     simpleChildTask.triggerAndWait({ payload })
+    //   )
+    // );
+  },
+});

From 715d1b977254b179bea4b9857f8dcb87328882c1 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Mon, 15 Apr 2024 17:30:38 +0100
Subject: [PATCH 08/11] advice in docs re parallel dependency waits

---
 docs/v3/triggering.mdx | 78 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)

diff --git a/docs/v3/triggering.mdx b/docs/v3/triggering.mdx
index c0f5acbe31c..be9dabe7a81 100644
--- a/docs/v3/triggering.mdx
+++ b/docs/v3/triggering.mdx
@@ -161,6 +161,43 @@ export const myTask = task({
 
 This is where it gets interesting. You can trigger a task and then wait for the result. This is useful when you need to call a different task and then use the result to continue with your task.
 
+<Accordion title="Don't use this in parallel, e.g. with `Promise.all()`">
+  Instead, use `batchTriggerAndWait()` if you can, or a for loop if you can't.
+
+<CodeGroup>
+```ts /trigger/batch.ts
+export const batchTask = task({
+  id: "batch-task",
+  run: async (payload: string) => {
+    const results = await childTask.batchTriggerAndWait({
+      items: [{ payload: "item1" }, { payload: "item2" }],
+      // optional: how many to run in parallel
+      batchOptions: { maxConcurrency: 1 },
+    });
+    console.log("Results", results);
+
+    //...do stuff with the results
+  },
+});
+```
+
+```ts /trigger/loop.ts
+export const loopTask = task({
+  id: "loop-task",
+  run: async (payload: string) => {
+    for (let i = 0; i < 2; i++) {
+      const result = await childTask.triggerAndWait({ payload: `item${i}` });
+      console.log("Result", result);
+
+      //...do stuff with the result
+    }
+  },
+});
+```
+</CodeGroup>
+
+</Accordion>
+
 ```ts /trigger/parent.ts
 export const parentTask = task({
   id: "parent-task",
@@ -177,6 +214,47 @@ export const parentTask = task({
 
 You can batch trigger a task and wait for all the results. This is useful for the fan-out pattern, where you need to call a task multiple times and then wait for all the results to continue with your task.
 
+<Accordion title="Don't use this in parallel, e.g. with `Promise.all()`">
+  Instead, pass in all items at once and set an appropriate `maxConcurrency`. Alternatively, use sequentially with a for loop.
+
+<CodeGroup>
+```ts /trigger/batch.ts
+export const batchTask = task({
+  id: "batch-task",
+  run: async (payload: string) => {
+    const results = await childTask.batchTriggerAndWait({
+      items: [{ payload: "item1" }, { payload: "item2" }],
+      // optional: how many tasks to run in parallel
+      batchOptions: { maxConcurrency: 1 },
+    });
+    console.log("Results", results);
+
+    //...do stuff with the results
+  },
+});
+```
+
+```ts /trigger/loop.ts
+export const loopTask = task({
+  id: "loop-task",
+  run: async (payload: string) => {
+    for (let i = 0; i < 2; i++) {
+      const result = await childTask.batchTriggerAndWait({
+        items: [{ payload: `itemA${i}` }, { payload: `itemB${i}` }],
+        // optional: how many tasks to run in parallel
+        batchOptions: { maxConcurrency: 1 },
+      });
+      console.log("Result", result);
+
+      //...do stuff with the result
+    }
+  },
+});
+```
+</CodeGroup>
+
+</Accordion>
+
 ```ts /trigger/nested.ts
 export const batchParentTask = task({
   id: "parent-task",

From 8cadf6078355543f951f6143cd48b3a81ba91c35 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Mon, 15 Apr 2024 19:31:09 +0100
Subject: [PATCH 09/11] fix link from v3 to v2 docs

---
 docs/mint.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/mint.json b/docs/mint.json
index a89a21abf85..3f998e2436e 100644
--- a/docs/mint.json
+++ b/docs/mint.json
@@ -49,7 +49,7 @@
     },
     {
       "name": "v2",
-      "url": "https://trigger.dev/docs",
+      "url": "https://trigger.dev/docs/documentation",
       "version": "v3 (Developer Preview)"
     },
     {

From a7c10cebd0ec7fdc16d1cfa90c4865dc1676bc16 Mon Sep 17 00:00:00 2001
From: nicktrn <55853254+nicktrn@users.noreply.github.com>
Date: Thu, 18 Apr 2024 09:40:05 +0100
Subject: [PATCH 10/11] move lifecycle command logging to debug only

---
 apps/kubernetes-provider/src/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/kubernetes-provider/src/index.ts b/apps/kubernetes-provider/src/index.ts
index 656986e37ec..569d5035f68 100644
--- a/apps/kubernetes-provider/src/index.ts
+++ b/apps/kubernetes-provider/src/index.ts
@@ -409,7 +409,7 @@ class KubernetesTaskOperations implements TaskOperations {
       `for i in $(seq ${retries}); do sleep 1; busybox wget -q -O- 127.0.0.1:8000/${type}?cause=${cause} && break; done`,
     ];
 
-    logger.log("getLifecycleCommand()", { exec });
+    logger.debug("getLifecycleCommand()", { exec });
 
     return exec;
   }

From bb95118e626df07bb57f51df0283479063c1367c Mon Sep 17 00:00:00 2001
From: Matt Aitken <matt@mattaitken.com>
Date: Thu, 18 Apr 2024 13:58:49 +0100
Subject: [PATCH 11/11] Removed batchOptions from the trigger options and the
 docs

---
 .changeset/smart-needles-move.md      |  5 +++++
 docs/v3/triggering.mdx                | 14 ++++++++------
 packages/trigger-sdk/src/v3/shared.ts |  4 ++--
 3 files changed, 15 insertions(+), 8 deletions(-)
 create mode 100644 .changeset/smart-needles-move.md

diff --git a/.changeset/smart-needles-move.md b/.changeset/smart-needles-move.md
new file mode 100644
index 00000000000..78b67eac01b
--- /dev/null
+++ b/.changeset/smart-needles-move.md
@@ -0,0 +1,5 @@
+---
+"@trigger.dev/sdk": patch
+---
+
+Remove unimplemented batchOptions
diff --git a/docs/v3/triggering.mdx b/docs/v3/triggering.mdx
index 4bc09a387a8..83880d7e7eb 100644
--- a/docs/v3/triggering.mdx
+++ b/docs/v3/triggering.mdx
@@ -168,6 +168,8 @@ This is where it gets interesting. You can trigger a task and then wait for the
 <Accordion title="Don't use this in parallel, e.g. with `Promise.all()`">
   Instead, use `batchTriggerAndWait()` if you can, or a for loop if you can't.
 
+  To control concurrency using batch triggers, you can set `queue.concurrencyLimit` on the child task.
+
 <CodeGroup>
 ```ts /trigger/batch.ts
 export const batchTask = task({
@@ -175,8 +177,6 @@ export const batchTask = task({
   run: async (payload: string) => {
     const results = await childTask.batchTriggerAndWait({
       items: [{ payload: "item1" }, { payload: "item2" }],
-      // optional: how many to run in parallel
-      batchOptions: { maxConcurrency: 1 },
     });
     console.log("Results", results);
 
@@ -189,6 +189,8 @@ export const batchTask = task({
 export const loopTask = task({
   id: "loop-task",
   run: async (payload: string) => {
+    //this will be slower than the batch version
+    //as we have to resume the parent after each iteration
     for (let i = 0; i < 2; i++) {
       const result = await childTask.triggerAndWait({ payload: `item${i}` });
       console.log("Result", result);
@@ -221,6 +223,8 @@ You can batch trigger a task and wait for all the results. This is useful for th
 <Accordion title="Don't use this in parallel, e.g. with `Promise.all()`">
   Instead, pass in all items at once and set an appropriate `maxConcurrency`. Alternatively, use sequentially with a for loop.
 
+  To control concurrency, you can set `queue.concurrencyLimit` on the child task.
+
 <CodeGroup>
 ```ts /trigger/batch.ts
 export const batchTask = task({
@@ -228,8 +232,6 @@ export const batchTask = task({
   run: async (payload: string) => {
     const results = await childTask.batchTriggerAndWait({
       items: [{ payload: "item1" }, { payload: "item2" }],
-      // optional: how many tasks to run in parallel
-      batchOptions: { maxConcurrency: 1 },
     });
     console.log("Results", results);
 
@@ -242,11 +244,11 @@ export const batchTask = task({
 export const loopTask = task({
   id: "loop-task",
   run: async (payload: string) => {
+    //this will be slower than a single batchTriggerAndWait()
+    //as we have to resume the parent after each iteration
     for (let i = 0; i < 2; i++) {
       const result = await childTask.batchTriggerAndWait({
         items: [{ payload: `itemA${i}` }, { payload: `itemB${i}` }],
-        // optional: how many tasks to run in parallel
-        batchOptions: { maxConcurrency: 1 },
       });
       console.log("Result", result);
 
diff --git a/packages/trigger-sdk/src/v3/shared.ts b/packages/trigger-sdk/src/v3/shared.ts
index 63bc62774a6..2f5c29cb4e6 100644
--- a/packages/trigger-sdk/src/v3/shared.ts
+++ b/packages/trigger-sdk/src/v3/shared.ts
@@ -179,12 +179,12 @@ export interface Task<TInput, TOutput = any> {
   trigger: (params: { payload: TInput; options?: TaskRunOptions }) => Promise<InvokeHandle>;
   batchTrigger: (params: {
     items: { payload: TInput; options?: TaskRunOptions }[];
-    batchOptions?: BatchRunOptions;
+    // batchOptions?: BatchRunOptions;
   }) => Promise<InvokeBatchHandle>;
   triggerAndWait: (params: { payload: TInput; options?: TaskRunOptions }) => Promise<TOutput>;
   batchTriggerAndWait: (params: {
     items: { payload: TInput; options?: TaskRunOptions }[];
-    batchOptions?: BatchRunOptions;
+    // batchOptions?: BatchRunOptions;
   }) => Promise<BatchResult<TOutput>>;
 }