Ensure the task list uses the dev environment of the logged in user

Author: ericallam

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

@@ -1,19 +1,15 @@
+import { CURRENT_DEPLOYMENT_LABEL } from "@trigger.dev/core/v3/isomorphic";
 import {
   Prisma,
-  type TaskTriggerSource,
-  type TaskRunStatus as TaskRunStatusType,
-  type RuntimeEnvironment,
   type TaskRunStatus as DBTaskRunStatus,
+  type TaskRunStatus as TaskRunStatusType,
+  type TaskTriggerSource,
 } from "@trigger.dev/database";
 import { QUEUED_STATUSES } from "~/components/runs/v3/TaskRunStatus";
+import { TaskRunStatus } from "~/database-types";
 import { sqlDatabaseSchema } from "~/db.server";
-import type { Organization } from "~/models/organization.server";
-import type { Project } from "~/models/project.server";
-import type { User } from "~/models/user.server";
 import { logger } from "~/services/logger.server";
 import { BasePresenter } from "./basePresenter.server";
-import { TaskRunStatus } from "~/database-types";
-import { CURRENT_DEPLOYMENT_LABEL } from "@trigger.dev/core/v3/isomorphic";
 
 export type TaskListItem = {
   slug: string;
@@ -27,34 +23,7 @@ type Return = Awaited<ReturnType<TaskListPresenter["call"]>>;
 export type TaskActivity = Awaited<Return["activity"]>[string];
 
 export class TaskListPresenter extends BasePresenter {
-  public async call({
-    userId,
-    projectSlug,
-    organizationSlug,
-    environmentSlug,
-  }: {
-    userId: User["id"];
-    projectSlug: Project["slug"];
-    organizationSlug: Organization["slug"];
-    environmentSlug: RuntimeEnvironment["slug"];
-  }) {
-    const environment = await this._replica.runtimeEnvironment.findFirstOrThrow({
-      select: {
-        id: true,
-        type: true,
-        projectId: true,
-      },
-      where: {
-        slug: environmentSlug,
-        project: {
-          slug: projectSlug,
-        },
-        organization: {
-          slug: organizationSlug,
-        },
-      },
-    });
-
+  public async call({ environmentId, projectId }: { environmentId: string; projectId: string }) {
     const tasks = await this._replica.$queryRaw<
       {
         id: string;
@@ -69,13 +38,13 @@ export class TaskListPresenter extends BasePresenter {
       FROM ${sqlDatabaseSchema}."WorkerDeploymentPromotion" wdp
       INNER JOIN ${sqlDatabaseSchema}."WorkerDeployment" wd
         ON wd.id = wdp."deploymentId"
-      WHERE wdp."environmentId" = ${environment.id}
+      WHERE wdp."environmentId" = ${environmentId}
         AND wdp."label" = ${CURRENT_DEPLOYMENT_LABEL}
     ),
     workers AS (
       SELECT DISTINCT ON ("runtimeEnvironmentId") id, "runtimeEnvironmentId", version
       FROM ${sqlDatabaseSchema}."BackgroundWorker"
-      WHERE "runtimeEnvironmentId" = ${environment.id}
+      WHERE "runtimeEnvironmentId" = ${environmentId}
         OR id IN (SELECT id FROM non_dev_workers)
       ORDER BY "runtimeEnvironmentId", "createdAt" DESC
     )
@@ -87,23 +56,23 @@ export class TaskListPresenter extends BasePresenter {
     //then get the activity for each task
     const activity = this.#getActivity(
       tasks.map((t) => t.slug),
-      environment.projectId,
-      environment.id
+      projectId,
+      environmentId
     );
 
     const runningStats = this.#getRunningStats(
       tasks.map((t) => t.slug),
-      environment.projectId,
-      environment.id
+      projectId,
+      environmentId
     );
 
     const durations = this.#getAverageDurations(
       tasks.map((t) => t.slug),
-      environment.projectId,
-      environment.id
+      projectId,
+      environmentId
     );
 
-    return { tasks, environment, activity, runningStats, durations };
+    return { tasks, activity, runningStats, durations };
   }
 
   async #getActivity(tasks: string[], projectId: string, environmentId: string) {

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

@@ -70,6 +70,8 @@ import { useEventSource } from "~/hooks/useEventSource";
 import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
 import { useTextFilter } from "~/hooks/useTextFilter";
+import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
 import {
   type TaskActivity,
   type TaskListItem,
@@ -104,20 +106,33 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const userId = await requireUserId(request);
   const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
 
+  const project = await findProjectBySlug(organizationSlug, projectParam, userId);
+  if (!project) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Project not found",
+    });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, userId);
+  if (!environment) {
+    throw new Response(undefined, {
+      status: 404,
+      statusText: "Environment not found",
+    });
+  }
+
   try {
     const presenter = new TaskListPresenter();
-    const { tasks, environment, activity, runningStats, durations } = await presenter.call({
-      userId,
-      organizationSlug,
-      projectSlug: projectParam,
-      environmentSlug: envParam,
+    const { tasks, activity, runningStats, durations } = await presenter.call({
+      environmentId: environment.id,
+      projectId: project.id,
     });
 
     const usefulLinksPreference = await getUsefulLinksPreference(request);
 
     return typeddefer({
       tasks,
-      environment,
       activity,
       runningStats,
       durations,