Apply run options in replays

myftija · myftija · commit c8958ac8749f · 2025-07-11T09:51:45.000+02:00
diff --git a/apps/webapp/app/components/runs/v3/ReplayRunDialog.tsx b/apps/webapp/app/components/runs/v3/ReplayRunDialog.tsx
@@ -36,7 +36,7 @@ import { TabButton, TabContainer } from "~/components/primitives/Tabs";
 import { TextLink } from "~/components/primitives/TextLink";
 import { type loader } from "~/routes/resources.taskruns.$runParam.replay";
 import { docsPath } from "~/utils/pathBuilder";
-import { ReplayTaskData } from "~/v3/replayTask";
+import { ReplayRunData } from "~/v3/replayTask";
 import { RectangleStackIcon } from "@heroicons/react/20/solid";
 import { Badge } from "~/components/primitives/Badge";
 import { RunTagInput } from "./RunTagInput";
@@ -148,27 +148,6 @@ function ReplayForm({
     replayData.payloadType === "application/json" ||
     replayData.payloadType === "application/super+json";
 
-  const submitForm = useCallback(
-    (e: React.FormEvent<HTMLFormElement>) => {
-      const formData = new FormData(e.currentTarget);
-      const data: Record<string, string> = {
-        environment: formData.get("environment") as string,
-        failedRedirect: formData.get("failedRedirect") as string,
-      };
-
-      if (editablePayload) {
-        data.payload = currentPayloadJson.current;
-      }
-
-      submit(data, {
-        action: formAction,
-        method: "post",
-      });
-      e.preventDefault();
-    },
-    [currentPayloadJson]
-  );
-
   const [tab, setTab] = useState<"payload" | "metadata">("payload");
 
   const { defaultTaskQueue } = replayData;
@@ -217,16 +196,16 @@ function ReplayForm({
       submit(formData, { method: "POST", action: formAction });
     },
     onValidate({ formData }) {
-      return parse(formData, { schema: ReplayTaskData });
+      return parse(formData, { schema: ReplayRunData });
     },
   });
 
   return (
     <Form
       action={formAction}
       method="post"
-      onSubmit={(e) => submitForm(e)}
       className="flex flex-1 flex-col overflow-hidden px-3"
+      {...form.props}
     >
       <input type="hidden" name="failedRedirect" value={failedRedirect} />
 
@@ -242,16 +221,16 @@ function ReplayForm({
           <div className="rounded-smbg-charcoal-900 mb-3 h-full min-h-40 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-charcoal-600">
             <JSONEditor
               autoFocus
-              defaultValue={!tab || tab === "payload" ? defaultPayloadJson : defaultMetadataJson}
+              defaultValue={tab === "payload" ? defaultPayloadJson : defaultMetadataJson}
               readOnly={false}
               basicSetup
               onChange={(v) => {
-                if (!tab || tab === "payload") {
+                if (tab === "payload") {
                   currentPayloadJson.current = v;
-                  setDefaultPayloadJson(v);
+                  setPayload(v);
                 } else {
                   currentMetadataJson.current = v;
-                  setDefaultMetadataJson(v);
+                  setMetadata(v);
                 }
               }}
               height="100%"
@@ -261,7 +240,7 @@ function ReplayForm({
                 <TabContainer className="flex grow items-baseline justify-between self-end border-none">
                   <div className="flex gap-5">
                     <TabButton
-                      isActive={!tab || tab === "payload"}
+                      isActive={tab === "payload"}
                       layoutId="replay-editor"
                       onClick={() => {
                         setTab("payload");
@@ -505,8 +484,7 @@ function ReplayForm({
           <InputGroup className="flex flex-row items-center">
             <Label>Replay this run in</Label>
             <Select
-              id="environment"
-              name="environment"
+              {...conform.select(environment)}
               placeholder="Select an environment"
               defaultValue={replayData.environment.id}
               items={replayData.environments}
diff --git a/apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts b/apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts
@@ -14,6 +14,7 @@ import { ReplayTaskRunService } from "~/v3/services/replayTaskRun.server";
 import parseDuration from "parse-duration";
 import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
 import { queueTypeFromType } from "~/presenters/v3/QueueRetrievePresenter.server";
+import { ReplayRunData } from "~/v3/replayTask";
 
 const ParamSchema = z.object({
   runParam: z.string(),
@@ -179,26 +180,18 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
   });
 }
 
-const FormSchema = z.object({
-  environment: z.string().optional(),
-  payload: z.string().optional(),
-  failedRedirect: z.string(),
-});
-
 export const action: ActionFunction = async ({ request, params }) => {
-  const userId = await requireUserId(request);
-
   const { runParam } = ParamSchema.parse(params);
 
   const formData = await request.formData();
-  const submission = parse(formData, { schema: FormSchema });
+  const submission = parse(formData, { schema: ReplayRunData });
 
   if (!submission.value) {
     return json(submission);
   }
 
   try {
-    const taskRun = await prisma.taskRun.findUnique({
+    const taskRun = await prisma.taskRun.findFirst({
       where: {
         friendlyId: runParam,
       },
@@ -224,6 +217,18 @@ export const action: ActionFunction = async ({ request, params }) => {
     const newRun = await replayRunService.call(taskRun, {
       environmentId: submission.value.environment,
       payload: submission.value.payload,
+      metadata: submission.value.metadata,
+      tags: submission.value.tags,
+      queue: submission.value.queue,
+      concurrencyKey: submission.value.concurrencyKey,
+      maxAttempts: submission.value.maxAttempts,
+      maxDurationSeconds: submission.value.maxDurationSeconds,
+      machine: submission.value.machine,
+      delaySeconds: submission.value.delaySeconds,
+      idempotencyKey: submission.value.idempotencyKey,
+      idempotencyKeyTTLSeconds: submission.value.idempotencyKeyTTLSeconds,
+      ttlSeconds: submission.value.ttlSeconds,
+      version: submission.value.version,
     });
 
     if (!newRun) {
diff --git a/apps/webapp/app/v3/replayTask.ts b/apps/webapp/app/v3/replayTask.ts
@@ -1,13 +1,47 @@
 import { z } from "zod";
 import { RunOptionsData } from "./testTask";
 
-export const ReplayTaskData = z
+export const ReplayRunData = z
   .object({
     environment: z.string().optional(),
-    payload: z.string().optional(),
-    metadata: z.string().optional(),
+    payload: z
+      .string()
+      .optional()
+      .transform((val, ctx) => {
+        if (!val) {
+          return {};
+        }
+
+        try {
+          return JSON.parse(val);
+        } catch {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Payload must be a valid JSON string",
+          });
+          return z.NEVER;
+        }
+      }),
+    metadata: z
+      .string()
+      .optional()
+      .transform((val, ctx) => {
+        if (!val) {
+          return {};
+        }
+
+        try {
+          return JSON.parse(val);
+        } catch {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Metadata must be a valid JSON string",
+          });
+          return z.NEVER;
+        }
+      }),
     failedRedirect: z.string(),
   })
   .and(RunOptionsData);
 
-export type ReplayTaskData = z.infer<typeof ReplayTaskData>;
+export type ReplayRunData = z.infer<typeof ReplayRunData>;
diff --git a/apps/webapp/app/v3/services/replayTaskRun.server.ts b/apps/webapp/app/v3/services/replayTaskRun.server.ts
@@ -1,27 +1,26 @@
 import {
+  type MachinePresetName,
   conditionallyImportPacket,
-  IOPacket,
   parsePacket,
-  RunTags,
-  stringifyIO,
 } from "@trigger.dev/core/v3";
-import { replaceSuperJsonPayload } from "@trigger.dev/core/v3/utils/ioSerialization";
-import { TaskRun } from "@trigger.dev/database";
+import { type TaskRun } from "@trigger.dev/database";
 import { findEnvironmentById } from "~/models/runtimeEnvironment.server";
 import { getTagsForRunId } from "~/models/taskRunTag.server";
 import { logger } from "~/services/logger.server";
 import { BaseService } from "./baseService.server";
 import { OutOfEntitlementError, TriggerTaskService } from "./triggerTask.server";
+import { type RunOptionsData } from "../testTask";
 
 type OverrideOptions = {
   environmentId?: string;
-  payload?: string;
-};
+  payload?: unknown;
+  metadata?: unknown;
+} & RunOptionsData;
 
 export class ReplayTaskRunService extends BaseService {
-  public async call(existingTaskRun: TaskRun, overrideOptions?: OverrideOptions) {
+  public async call(existingTaskRun: TaskRun, overrideOptions: OverrideOptions = {}) {
     const authenticatedEnvironment = await findEnvironmentById(
-      overrideOptions?.environmentId ?? existingTaskRun.runtimeEnvironmentId
+      overrideOptions.environmentId ?? existingTaskRun.runtimeEnvironmentId
     );
     if (!authenticatedEnvironment) {
       return;
@@ -36,57 +35,41 @@ export class ReplayTaskRunService extends BaseService {
       taskRunFriendlyId: existingTaskRun.friendlyId,
     });
 
-    let payloadPacket: IOPacket;
-
-    if (overrideOptions?.payload) {
-      if (existingTaskRun.payloadType === "application/super+json") {
-        const newPayload = await replaceSuperJsonPayload(
-          existingTaskRun.payload,
-          overrideOptions.payload
-        );
-        payloadPacket = await stringifyIO(newPayload);
-      } else {
-        payloadPacket = await conditionallyImportPacket({
-          data: overrideOptions.payload,
-          dataType: existingTaskRun.payloadType,
-        });
-      }
-    } else {
-      payloadPacket = await conditionallyImportPacket({
+    const getExistingPayload = async () => {
+      const existingPayloadPacket = await conditionallyImportPacket({
         data: existingTaskRun.payload,
         dataType: existingTaskRun.payloadType,
       });
-    }
 
-    const parsedPayload =
-      payloadPacket.dataType === "application/json"
-        ? await parsePacket(payloadPacket)
-        : payloadPacket.data;
-
-    logger.info("Replaying task run payload", {
-      taskRunId: existingTaskRun.id,
-      taskRunFriendlyId: existingTaskRun.friendlyId,
-      payloadPacketType: payloadPacket.dataType,
-    });
+      return existingPayloadPacket.dataType === "application/json"
+        ? await parsePacket(existingPayloadPacket)
+        : existingPayloadPacket.data;
+    };
 
-    const metadata = existingTaskRun.seedMetadata
-      ? await parsePacket({
-          data: existingTaskRun.seedMetadata,
-          dataType: existingTaskRun.seedMetadataType,
-        })
-      : undefined;
+    const payload = overrideOptions.payload ?? (await getExistingPayload());
+    const metadata =
+      overrideOptions.metadata ??
+      (existingTaskRun.seedMetadata
+        ? await parsePacket({
+            data: existingTaskRun.seedMetadata,
+            dataType: existingTaskRun.seedMetadataType,
+          })
+        : undefined);
 
     try {
-      const tags = await getTagsForRunId({
-        friendlyId: existingTaskRun.friendlyId,
-        environmentId: authenticatedEnvironment.id,
-      });
+      const tags =
+        overrideOptions.tags ??
+        (
+          await getTagsForRunId({
+            friendlyId: existingTaskRun.friendlyId,
+            environmentId: authenticatedEnvironment.id,
+          })
+        )?.map((t) => t.name);
 
-      //get the queue from the original run, so we can use the same settings on the replay
       const taskQueue = await this._prisma.taskQueue.findFirst({
         where: {
           runtimeEnvironmentId: authenticatedEnvironment.id,
-          name: existingTaskRun.queue,
+          name: overrideOptions.queue ?? existingTaskRun.queue,
         },
       });
 
@@ -95,18 +78,34 @@ export class ReplayTaskRunService extends BaseService {
         existingTaskRun.taskIdentifier,
         authenticatedEnvironment,
         {
-          payload: parsedPayload,
+          payload,
           options: {
             queue: taskQueue
               ? {
                   name: taskQueue.name,
                 }
               : undefined,
-            concurrencyKey: existingTaskRun.concurrencyKey ?? undefined,
             test: existingTaskRun.isTest,
-            payloadType: payloadPacket.dataType,
-            tags: tags?.map((t) => t.name) as RunTags,
-            metadata,
+            tags,
+            metadata: metadata,
+            delay: overrideOptions.delaySeconds
+              ? new Date(Date.now() + overrideOptions.delaySeconds * 1000)
+              : undefined,
+            ttl: overrideOptions.ttlSeconds,
+            idempotencyKey: overrideOptions.idempotencyKey,
+            idempotencyKeyTTL: overrideOptions.idempotencyKeyTTLSeconds
+              ? `${overrideOptions.idempotencyKeyTTLSeconds}s`
+              : undefined,
+            concurrencyKey:
+              overrideOptions.concurrencyKey ?? existingTaskRun.concurrencyKey ?? undefined,
+            maxAttempts: overrideOptions.maxAttempts,
+            maxDuration: overrideOptions.maxDurationSeconds,
+            machine:
+              overrideOptions.machine ??
+              (existingTaskRun.machinePreset as MachinePresetName) ??
+              undefined,
+            lockToVersion:
+              overrideOptions.version === "latest" ? undefined : overrideOptions.version,
           },
         },
         {
diff --git a/apps/webapp/app/v3/testTask.ts b/apps/webapp/app/v3/testTask.ts
@@ -48,6 +48,8 @@ export const RunOptionsData = z.object({
   version: z.string().optional(),
 });
 
+export type RunOptionsData = z.infer<typeof RunOptionsData>;
+
 export const TestTaskData = z
   .discriminatedUnion("triggerSource", [
     z.object({
