Flatten the load function test task result object

Author: myftija

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

@@ -23,44 +23,48 @@ type Task = {
   friendlyId: string;
 };
 
-export type TestTask =
+type Queue = {
+  id: string;
+  name: string;
+  type: "custom" | "task";
+  paused: boolean;
+};
+
+export type TestTaskResult =
   | {
+      foundTask: true;
       triggerSource: "STANDARD";
-      queue?: {
-        id: string;
-        name: string;
-        type: "custom" | "task";
-        paused: boolean;
-      };
+      queue?: Queue;
       task: Task;
       runs: StandardRun[];
       latestVersions: string[];
+      disableVersionSelection: boolean;
+      allowArbitraryQueues: boolean;
     }
   | {
+      foundTask: true;
       triggerSource: "SCHEDULED";
-      queue?: {
-        id: string;
-        name: string;
-        type: "custom" | "task";
-        paused: boolean;
-      };
+      queue?: Queue;
       task: Task;
       possibleTimezones: string[];
       runs: ScheduledRun[];
       latestVersions: string[];
-    };
-
-export type TestTaskResult =
-  | {
-      foundTask: true;
-      task: TestTask;
       disableVersionSelection: boolean;
       allowArbitraryQueues: boolean;
     }
   | {
       foundTask: false;
     };
 
+export type StandardTaskResult = Extract<
+  TestTaskResult,
+  { foundTask: true; triggerSource: "STANDARD" }
+>;
+export type ScheduledTaskResult = Extract<
+  TestTaskResult,
+  { foundTask: true; triggerSource: "SCHEDULED" }
+>;
+
 type RawRun = {
   id: string;
   queue: string;
@@ -217,71 +221,71 @@ export class TestTaskPresenter {
       case "STANDARD":
         return {
           foundTask: true,
-          task: {
-            triggerSource: "STANDARD",
-            queue: taskQueue
-              ? {
-                  id: taskQueue.friendlyId,
-                  name: taskQueue.name.replace(/^task\//, ""),
-                  type: queueTypeFromType(taskQueue.type),
-                  paused: taskQueue.paused,
-                }
-              : undefined,
-            task: taskWithEnvironment,
-            runs: await Promise.all(
-              latestRuns.map(
-                async (r) =>
-                  ({
-                    ...r,
-                    payload: await prettyPrintPacket(r.payload, r.payloadType),
-                    metadata: r.seedMetadata
-                      ? await prettyPrintPacket(r.seedMetadata, r.seedMetadataType)
-                      : undefined,
-                    ttlSeconds: r.ttl ? parse(r.ttl, "s") ?? undefined : undefined,
-                  } satisfies StandardRun)
-              )
-            ),
-            latestVersions,
-          },
+          triggerSource: "STANDARD",
+          queue: taskQueue
+            ? {
+                id: taskQueue.friendlyId,
+                name: taskQueue.name.replace(/^task\//, ""),
+                type: queueTypeFromType(taskQueue.type),
+                paused: taskQueue.paused,
+              }
+            : undefined,
+          task: taskWithEnvironment,
+          runs: await Promise.all(
+            latestRuns.map(
+              async (r) =>
+                ({
+                  ...r,
+                  payload: await prettyPrintPacket(r.payload, r.payloadType),
+                  metadata: r.seedMetadata
+                    ? await prettyPrintPacket(r.seedMetadata, r.seedMetadataType)
+                    : undefined,
+                  ttlSeconds: r.ttl ? parse(r.ttl, "s") ?? undefined : undefined,
+                } satisfies StandardRun)
+            )
+          ),
+          latestVersions,
           disableVersionSelection,
           allowArbitraryQueues,
         };
-      case "SCHEDULED":
+      case "SCHEDULED": {
         const possibleTimezones = getTimezones();
         return {
           foundTask: true,
-          task: {
-            triggerSource: "SCHEDULED",
-            queue: taskQueue
-              ? {
-                  id: taskQueue.friendlyId,
-                  name: taskQueue.name.replace(/^task\//, ""),
-                  type: queueTypeFromType(taskQueue.type),
-                  paused: taskQueue.paused,
-                }
-              : undefined,
-            task: taskWithEnvironment,
-            possibleTimezones,
-            runs: (
-              await Promise.all(
-                latestRuns.map(async (r) => {
-                  const payload = await getScheduleTaskRunPayload(r);
+          triggerSource: "SCHEDULED",
+          queue: taskQueue
+            ? {
+                id: taskQueue.friendlyId,
+                name: taskQueue.name.replace(/^task\//, ""),
+                type: queueTypeFromType(taskQueue.type),
+                paused: taskQueue.paused,
+              }
+            : undefined,
+          task: taskWithEnvironment,
+          possibleTimezones,
+          runs: (
+            await Promise.all(
+              latestRuns.map(async (r) => {
+                const payload = await getScheduleTaskRunPayload(r);
 
-                  if (payload.success) {
-                    return {
-                      ...r,
-                      payload: payload.data,
-                      ttlSeconds: r.ttl ? parse(r.ttl, "s") ?? undefined : undefined,
-                    } satisfies ScheduledRun;
-                  }
-                })
-              )
-            ).filter(Boolean),
-            latestVersions,
-          },
+                if (payload.success) {
+                  return {
+                    ...r,
+                    payload: payload.data,
+                    ttlSeconds: r.ttl ? parse(r.ttl, "s") ?? undefined : undefined,
+                  } satisfies ScheduledRun;
+                }
+              })
+            )
+          ).filter(Boolean),
+          latestVersions,
           disableVersionSelection,
           allowArbitraryQueues,
         };
+      }
+      default: {
+        return task.triggerSource satisfies never;
+      }
     }
   }
 }

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

@@ -42,7 +42,8 @@ import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
 import {
   type ScheduledRun,
   type StandardRun,
-  type TestTask,
+  type StandardTaskResult,
+  type ScheduledTaskResult,
   TestTaskPresenter,
 } from "~/presenters/v3/TestTaskPresenter.server";
 import { logger } from "~/services/logger.server";
@@ -186,7 +187,7 @@ export default function Page() {
     }
   }, [params.organizationSlug, params.projectParam, params.envParam]);
 
-  const defaultTaskQueue = result.task.queue;
+  const defaultTaskQueue = result.queue;
   const queues = useMemo(() => {
     const customQueues = queueFetcher.data?.queues ?? [];
 
@@ -195,14 +196,15 @@ export default function Page() {
       : customQueues;
   }, [queueFetcher.data?.queues, defaultTaskQueue]);
 
-  switch (result.task.triggerSource) {
+  const { triggerSource } = result;
+  switch (triggerSource) {
     case "STANDARD": {
       return (
         <StandardTaskForm
-          task={result.task.task}
+          task={result.task}
           queues={queues}
-          runs={result.task.runs}
-          versions={result.task.latestVersions}
+          runs={result.runs}
+          versions={result.latestVersions}
           disableVersionSelection={result.disableVersionSelection}
           allowArbitraryQueues={result.allowArbitraryQueues}
         />
@@ -211,18 +213,18 @@ export default function Page() {
     case "SCHEDULED": {
       return (
         <ScheduledTaskForm
-          task={result.task.task}
+          task={result.task}
           queues={queues}
-          runs={result.task.runs}
-          versions={result.task.latestVersions}
-          possibleTimezones={result.task.possibleTimezones}
+          runs={result.runs}
+          versions={result.latestVersions}
+          possibleTimezones={result.possibleTimezones}
           disableVersionSelection={result.disableVersionSelection}
           allowArbitraryQueues={result.allowArbitraryQueues}
         />
       );
     }
     default: {
-      return result.task satisfies never;
+      return triggerSource satisfies never;
     }
   }
 }
@@ -246,8 +248,8 @@ function StandardTaskForm({
   disableVersionSelection,
   allowArbitraryQueues,
 }: {
-  task: TestTask["task"];
-  queues: Required<TestTask>["queue"][];
+  task: StandardTaskResult["task"];
+  queues: Required<StandardTaskResult>["queue"][];
   runs: StandardRun[];
   versions: string[];
   disableVersionSelection: boolean;
@@ -660,10 +662,10 @@ function ScheduledTaskForm({
   disableVersionSelection,
   allowArbitraryQueues,
 }: {
-  task: TestTask["task"];
+  task: ScheduledTaskResult["task"];
   runs: ScheduledRun[];
   possibleTimezones: string[];
-  queues: Required<TestTask>["queue"][];
+  queues: Required<ScheduledTaskResult>["queue"][];
   versions: string[];
   disableVersionSelection: boolean;
   allowArbitraryQueues: boolean;