Test page uses the taskIdentifier in the path

Author: matt-aitken

apps/webapp/app/presenters/v3/TestPresenter.server.ts

@@ -113,10 +113,10 @@ export class TestPresenter extends BasePresenter {
           triggerSource: TaskTriggerSource;
         }[]
       >`WITH workers AS (
-          SELECT 
+          SELECT
                 bw.*,
                 ROW_NUMBER() OVER(ORDER BY string_to_array(bw.version, '.')::int[] DESC) AS rn
-          FROM 
+          FROM
                 ${sqlDatabaseSchema}."BackgroundWorker" bw
           WHERE "runtimeEnvironmentId" = ${envId}
         ),

apps/webapp/app/presenters/v3/TestTaskPresenter.server.ts

@@ -1,13 +1,15 @@
 import { ScheduledTaskPayload, parsePacket, prettyPrintPacket } from "@trigger.dev/core/v3";
-import { RuntimeEnvironmentType, TaskRunStatus } from "@trigger.dev/database";
+import { BackgroundWorkerTask, RuntimeEnvironmentType, TaskRunStatus } from "@trigger.dev/database";
 import { PrismaClient, prisma, sqlDatabaseSchema } from "~/db.server";
 import { getTimezones } from "~/utils/timezones.server";
 import { getUsername } from "~/utils/username";
+import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
 
 type TestTaskOptions = {
   userId: string;
   projectSlug: string;
-  taskFriendlyId: string;
+  environmentSlug: string;
+  taskIdentifier: string;
 };
 
 type Task = {
@@ -37,6 +39,15 @@ export type TestTask =
       runs: ScheduledRun[];
     };
 
+export type TestTaskResult =
+  | {
+      foundTask: true;
+      task: TestTask;
+    }
+  | {
+      foundTask: false;
+    };
+
 type RawRun = {
   id: string;
   number: BigInt;
@@ -71,55 +82,79 @@ export class TestTaskPresenter {
     this.#prismaClient = prismaClient;
   }
 
-  public async call({ userId, projectSlug, taskFriendlyId }: TestTaskOptions): Promise<TestTask> {
-    const task = await this.#prismaClient.backgroundWorkerTask.findFirstOrThrow({
+  public async call({
+    userId,
+    projectSlug,
+    environmentSlug,
+    taskIdentifier,
+  }: TestTaskOptions): Promise<TestTaskResult> {
+    const environment = await this.#prismaClient.runtimeEnvironment.findFirstOrThrow({
+      where: {
+        slug: environmentSlug,
+        project: {
+          slug: projectSlug,
+        },
+        orgMember: environmentSlug === "dev" ? { userId } : undefined,
+      },
       select: {
         id: true,
-        filePath: true,
-        exportName: true,
-        slug: true,
-        triggerSource: true,
-        runtimeEnvironment: {
+        type: true,
+        orgMember: {
           select: {
-            id: true,
-            type: true,
-            orgMember: {
+            user: {
               select: {
-                user: {
-                  select: {
-                    id: true,
-                    name: true,
-                    displayName: true,
-                  },
-                },
+                id: true,
+                name: true,
+                displayName: true,
               },
             },
           },
         },
       },
-      where: {
-        friendlyId: taskFriendlyId,
-      },
     });
 
+    let task: BackgroundWorkerTask | null = null;
+    if (environment.type !== "DEVELOPMENT") {
+      const deployment = await findCurrentWorkerDeployment(environment.id);
+      if (deployment) {
+        task = deployment.worker?.tasks.find((t) => t.slug === taskIdentifier) ?? null;
+      }
+    } else {
+      task = await this.#prismaClient.backgroundWorkerTask.findFirst({
+        where: {
+          slug: taskIdentifier,
+          runtimeEnvironmentId: environment.id,
+        },
+        orderBy: {
+          createdAt: "desc",
+        },
+      });
+    }
+
+    if (!task) {
+      return {
+        foundTask: false,
+      };
+    }
+
     const latestRuns = await this.#prismaClient.$queryRaw<RawRun[]>`
     WITH taskruns AS (
-      SELECT 
-          tr.* 
-      FROM 
+      SELECT
+          tr.*
+      FROM
           ${sqlDatabaseSchema}."TaskRun" as tr
       JOIN
           ${sqlDatabaseSchema}."BackgroundWorkerTask" as bwt
       ON
           tr."taskIdentifier" = bwt.slug
       WHERE
-          bwt."friendlyId" = ${taskFriendlyId} AND
-          tr."runtimeEnvironmentId" = ${task.runtimeEnvironment.id}
-      ORDER BY 
+          bwt."friendlyId" = ${task.friendlyId} AND
+          tr."runtimeEnvironmentId" = ${environment.id}
+      ORDER BY
           tr."createdAt" DESC
       LIMIT 5
     )
-    SELECT 
+    SELECT
         taskr.id,
         taskr.number,
         taskr."friendlyId",
@@ -131,7 +166,7 @@ export class TestTaskPresenter {
         taskr."seedMetadata",
         taskr."seedMetadataType",
         taskr."runtimeEnvironmentId"
-    FROM 
+    FROM
         taskruns AS taskr
     WHERE
         taskr."payloadType" = 'application/json' OR taskr."payloadType" = 'application/super+json'
@@ -143,58 +178,64 @@ export class TestTaskPresenter {
       taskIdentifier: task.slug,
       filePath: task.filePath,
       exportName: task.exportName,
-      friendlyId: taskFriendlyId,
+      friendlyId: task.friendlyId,
       environment: {
-        id: task.runtimeEnvironment.id,
-        type: task.runtimeEnvironment.type,
-        userId: task.runtimeEnvironment.orgMember?.user.id,
-        userName: getUsername(task.runtimeEnvironment.orgMember?.user),
+        id: environment.id,
+        type: environment.type,
+        userId: environment.orgMember?.user.id,
+        userName: getUsername(environment.orgMember?.user),
       },
     };
 
     switch (task.triggerSource) {
       case "STANDARD":
         return {
-          triggerSource: "STANDARD",
-          task: taskWithEnvironment,
-          runs: await Promise.all(
-            latestRuns.map(async (r) => {
-              const number = Number(r.number);
-
-              return {
-                ...r,
-                number,
-                payload: await prettyPrintPacket(r.payload, r.payloadType),
-                metadata: r.seedMetadata
-                  ? await prettyPrintPacket(r.seedMetadata, r.seedMetadataType)
-                  : undefined,
-              };
-            })
-          ),
-        };
-      case "SCHEDULED":
-        const possibleTimezones = getTimezones();
-        return {
-          triggerSource: "SCHEDULED",
-          task: taskWithEnvironment,
-          possibleTimezones,
-          runs: (
-            await Promise.all(
+          foundTask: true,
+          task: {
+            triggerSource: "STANDARD",
+            task: taskWithEnvironment,
+            runs: await Promise.all(
               latestRuns.map(async (r) => {
                 const number = Number(r.number);
 
-                const payload = await getScheduleTaskRunPayload(r);
-
-                if (payload.success) {
-                  return {
-                    ...r,
-                    number,
-                    payload: payload.data,
-                  };
-                }
+                return {
+                  ...r,
+                  number,
+                  payload: await prettyPrintPacket(r.payload, r.payloadType),
+                  metadata: r.seedMetadata
+                    ? await prettyPrintPacket(r.seedMetadata, r.seedMetadataType)
+                    : undefined,
+                };
               })
-            )
-          ).filter(Boolean),
+            ),
+          },
+        };
+      case "SCHEDULED":
+        const possibleTimezones = getTimezones();
+        return {
+          foundTask: true,
+          task: {
+            triggerSource: "SCHEDULED",
+            task: taskWithEnvironment,
+            possibleTimezones,
+            runs: (
+              await Promise.all(
+                latestRuns.map(async (r) => {
+                  const number = Number(r.number);
+
+                  const payload = await getScheduleTaskRunPayload(r);
+
+                  if (payload.success) {
+                    return {
+                      ...r,
+                      number,
+                      payload: payload.data,
+                    };
+                  }
+                })
+              )
+            ).filter(Boolean),
+          },
         };
     }
   }

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.v3.$projectParam.test.tasks.$taskParam/route.tsx

@@ -5,7 +5,7 @@ import { Form, useActionData, useSubmit } from "@remix-run/react";
 import { ActionFunction, LoaderFunctionArgs, json } from "@remix-run/server-runtime";
 import { TaskRunStatus } from "@trigger.dev/database";
 import { useCallback, useEffect, useRef, useState } from "react";
-import { typedjson, useTypedLoaderData } from "remix-typedjson";
+import { redirect, typedjson, useTypedLoaderData } from "remix-typedjson";
 import { JSONEditor } from "~/components/code/JSONEditor";
 import { EnvironmentLabel } from "~/components/environments/EnvironmentLabel";
 import { Button } from "~/components/primitives/Buttons";
@@ -32,7 +32,11 @@ import { TextLink } from "~/components/primitives/TextLink";
 import { TaskRunStatusCombo } from "~/components/runs/v3/TaskRunStatus";
 import { TimezoneList } from "~/components/scheduled/timezones";
 import { useSearchParams } from "~/hooks/useSearchParam";
-import { redirectBackWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
+import {
+  redirectBackWithErrorMessage,
+  redirectWithErrorMessage,
+  redirectWithSuccessMessage,
+} from "~/models/message.server";
 import {
   ScheduledRun,
   StandardRun,
@@ -42,7 +46,7 @@ import {
 import { logger } from "~/services/logger.server";
 import { requireUserId } from "~/services/session.server";
 import { cn } from "~/utils/cn";
-import { docsPath, v3RunSpanPath, v3TaskParamsSchema } from "~/utils/pathBuilder";
+import { docsPath, v3RunSpanPath, v3TaskParamsSchema, v3TestPath } from "~/utils/pathBuilder";
 import { TestTaskService } from "~/v3/services/testTask.server";
 import { OutOfEntitlementError } from "~/v3/services/triggerTask.server";
 import { TestTaskData } from "~/v3/testTask";
@@ -51,14 +55,30 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const userId = await requireUserId(request);
   const { projectParam, organizationSlug, taskParam } = v3TaskParamsSchema.parse(params);
 
-  const presenter = new TestTaskPresenter();
-  const result = await presenter.call({
-    userId,
-    projectSlug: projectParam,
-    taskFriendlyId: taskParam,
-  });
+  //need an environment
+  const searchParams = new URL(request.url).searchParams;
+  const environment = searchParams.get("environment");
+  if (!environment) {
+    return redirect(v3TestPath({ slug: organizationSlug }, { slug: projectParam }));
+  }
 
-  return typedjson(result);
+  const presenter = new TestTaskPresenter();
+  try {
+    const result = await presenter.call({
+      userId,
+      projectSlug: projectParam,
+      taskIdentifier: taskParam,
+      environmentSlug: environment,
+    });
+
+    return typedjson(result);
+  } catch (error) {
+    return redirectWithErrorMessage(
+      v3TestPath({ slug: organizationSlug }, { slug: projectParam }, environment),
+      request,
+      `Couldn't load test page for ${taskParam}`
+    );
+  }
 };
 
 export const action: ActionFunction = async ({ request, params }) => {
@@ -113,16 +133,20 @@ export const action: ActionFunction = async ({ request, params }) => {
 export default function Page() {
   const result = useTypedLoaderData<typeof loader>();
 
-  switch (result.triggerSource) {
+  if (!result.foundTask) {
+    return <div></div>;
+  }
+
+  switch (result.task.triggerSource) {
     case "STANDARD": {
-      return <StandardTaskForm task={result.task} runs={result.runs} />;
+      return <StandardTaskForm task={result.task.task} runs={result.task.runs} />;
     }
     case "SCHEDULED": {
       return (
         <ScheduledTaskForm
-          task={result.task}
-          runs={result.runs}
-          possibleTimezones={result.possibleTimezones}
+          task={result.task.task}
+          runs={result.task.runs}
+          possibleTimezones={result.task.possibleTimezones}
         />
       );
     }