Clean up a few excessive ternaries

Author: myftija

apps/webapp/app/routes/resources.taskruns.$runParam.replay.ts

@@ -1,6 +1,6 @@
 import { parse } from "@conform-to/zod";
 import { type ActionFunction, json, type LoaderFunctionArgs } from "@remix-run/node";
-import { prettyPrintPacket } from "@trigger.dev/core/v3";
+import { type EnvironmentType, prettyPrintPacket } from "@trigger.dev/core/v3";
 import { typedjson } from "remix-typedjson";
 import { z } from "zod";
 import { $replica, prisma } from "~/db.server";
@@ -99,54 +99,10 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
     throw new Response("Environment not found", { status: 404 });
   }
 
-  const task =
-    environment.type !== "DEVELOPMENT"
-      ? (
-          await findCurrentWorkerDeployment({
-            environmentId: environment.id,
-          })
-        )?.worker?.tasks.find((t) => t.slug === run.taskIdentifier)
-      : await $replica.backgroundWorkerTask.findFirst({
-          select: {
-            queueId: true,
-          },
-          where: {
-            slug: run.taskIdentifier,
-            runtimeEnvironmentId: environment.id,
-          },
-          orderBy: {
-            createdAt: "desc",
-          },
-        });
-
-  const taskQueue = task?.queueId
-    ? await $replica.taskQueue.findFirst({
-        where: {
-          runtimeEnvironmentId: environment.id,
-          id: task.queueId,
-        },
-        select: {
-          friendlyId: true,
-          name: true,
-          type: true,
-          paused: true,
-        },
-      })
-    : undefined;
-
-  const backgroundWorkers = await $replica.backgroundWorker.findMany({
-    where: {
-      runtimeEnvironmentId: environment.id,
-    },
-    select: {
-      version: true,
-      engine: true,
-    },
-    orderBy: {
-      createdAt: "desc",
-    },
-    take: 20, // last 20 versions should suffice
-  });
+  const [taskQueue, backgroundWorkers] = await Promise.all([
+    findTaskQueue(environment, run.taskIdentifier),
+    listLatestBackgroundWorkers(environment),
+  ]);
 
   const latestVersions = backgroundWorkers.map((v) => v.version);
   const disableVersionSelection = environment.type === "DEVELOPMENT";
@@ -182,16 +138,13 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
       branchName: environment.branchName ?? undefined,
     },
     environments: sortEnvironments(
-      run.project.environments.map((environment) => {
-        return {
-          ...displayableEnvironment(environment, userId),
-          branchName: environment.branchName ?? undefined,
-        };
-      })
-    ).filter((env) => {
-      if (env.type === "PREVIEW" && !env.branchName) return false;
-      return true;
-    }),
+      run.project.environments
+        .filter((env) => env.type !== "PREVIEW" || env.branchName)
+        .map((env) => ({
+          ...displayableEnvironment(env, userId),
+          branchName: env.branchName ?? undefined,
+        }))
+    ),
   });
 }
 
@@ -293,3 +246,68 @@ export const action: ActionFunction = async ({ request, params }) => {
     );
   }
 };
+
+async function findTask(
+  environment: { type: EnvironmentType; id: string },
+  taskIdentifier: string
+) {
+  if (environment.type === "DEVELOPMENT") {
+    return $replica.backgroundWorkerTask.findFirst({
+      select: {
+        queueId: true,
+      },
+      where: {
+        slug: taskIdentifier,
+        runtimeEnvironmentId: environment.id,
+      },
+      orderBy: {
+        createdAt: "desc",
+      },
+    });
+  }
+
+  const currentDeployment = await findCurrentWorkerDeployment({
+    environmentId: environment.id,
+  });
+  return currentDeployment?.worker?.tasks.find((t) => t.slug === taskIdentifier);
+}
+
+async function findTaskQueue(
+  environment: { type: EnvironmentType; id: string },
+  taskIdentifier: string
+) {
+  const task = await findTask(environment, taskIdentifier);
+
+  if (!task?.queueId) {
+    return undefined;
+  }
+
+  return $replica.taskQueue.findFirst({
+    where: {
+      runtimeEnvironmentId: environment.id,
+      id: task.queueId,
+    },
+    select: {
+      friendlyId: true,
+      name: true,
+      type: true,
+      paused: true,
+    },
+  });
+}
+
+function listLatestBackgroundWorkers(environment: { id: string }, limit = 20) {
+  return $replica.backgroundWorker.findMany({
+    where: {
+      runtimeEnvironmentId: environment.id,
+    },
+    select: {
+      version: true,
+      engine: true,
+    },
+    orderBy: {
+      createdAt: "desc",
+    },
+    take: limit,
+  });
+}

apps/webapp/app/v3/services/replayTaskRun.server.ts

@@ -35,37 +35,11 @@ export class ReplayTaskRunService extends BaseService {
       taskRunFriendlyId: existingTaskRun.friendlyId,
     });
 
-    const getExistingPayload = async () => {
-      const existingPayloadPacket = await conditionallyImportPacket({
-        data: existingTaskRun.payload,
-        dataType: existingTaskRun.payloadType,
-      });
-
-      return existingPayloadPacket.dataType === "application/json"
-        ? await parsePacket(existingPayloadPacket)
-        : existingPayloadPacket.data;
-    };
-
-    const payload = overrideOptions.payload ?? (await getExistingPayload());
-    const metadata =
-      overrideOptions.metadata ??
-      (existingTaskRun.seedMetadata
-        ? await parsePacket({
-            data: existingTaskRun.seedMetadata,
-            dataType: existingTaskRun.seedMetadataType,
-          })
-        : undefined);
+    const payload = overrideOptions.payload ?? (await this.getExistingPayload(existingTaskRun));
+    const metadata = overrideOptions.metadata ?? (await this.getExistingMetadata(existingTaskRun));
+    const tags = overrideOptions.tags ?? existingTaskRun.runTags;
 
     try {
-      const tags =
-        overrideOptions.tags ??
-        (
-          await getTagsForRunId({
-            friendlyId: existingTaskRun.friendlyId,
-            environmentId: authenticatedEnvironment.id,
-          })
-        )?.map((t) => t.name);
-
       const taskQueue = await this._prisma.taskQueue.findFirst({
         where: {
           runtimeEnvironmentId: authenticatedEnvironment.id,
@@ -130,4 +104,26 @@ export class ReplayTaskRunService extends BaseService {
       return;
     }
   }
+
+  private async getExistingPayload(existingTaskRun: TaskRun) {
+    const existingPayloadPacket = await conditionallyImportPacket({
+      data: existingTaskRun.payload,
+      dataType: existingTaskRun.payloadType,
+    });
+
+    return existingPayloadPacket.dataType === "application/json"
+      ? await parsePacket(existingPayloadPacket)
+      : existingPayloadPacket.data;
+  }
+
+  private async getExistingMetadata(existingTaskRun: TaskRun) {
+    if (!existingTaskRun.seedMetadata) {
+      return undefined;
+    }
+
+    return parsePacket({
+      data: existingTaskRun.seedMetadata,
+      dataType: existingTaskRun.seedMetadataType,
+    });
+  }
 }