Fix for run page on wrong env. Added schedule last triggered column

Author: matt-aitken

apps/webapp/app/components/runs/v3/TaskRunsTable.tsx

@@ -288,7 +288,7 @@ export function TaskRunsTable({
           <BlankState isLoading={isLoading} filters={filters} />
         ) : (
           runs.map((run, index) => {
-            const path = v3RunSpanPath(organization, project, environment, run, {
+            const path = v3RunSpanPath(organization, project, run.environment, run, {
               spanId: run.spanId,
             });
             return (

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

@@ -425,6 +425,8 @@ WHERE
         versions: versions || [],
         statuses: statuses || [],
         environments: environments || [],
+        from: time.from,
+        to: time.to,
       },
       hasFilters,
       hasAnyRuns,

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

@@ -2,6 +2,7 @@ import { millisecondsToNanoseconds } from "@trigger.dev/core/v3";
 import { createTreeFromFlatItems, flattenTree } from "~/components/primitives/TreeView/TreeView";
 import { createTimelineSpanEventsFromSpanEvents } from "~/components/run/RunTimeline";
 import { prisma, PrismaClient } from "~/db.server";
+import { redirectWithErrorMessage } from "~/models/message.server";
 import { getUsername } from "~/utils/username";
 import { eventRepository } from "~/v3/eventRepository.server";
 import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
@@ -11,6 +12,13 @@ type Result = Awaited<ReturnType<RunPresenter["call"]>>;
 export type Run = Result["run"];
 export type RunEvent = NonNullable<Result["trace"]>["events"][0];
 
+export class RunEnvironmentMismatchError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RunEnvironmentMismatchError";
+  }
+}
+
 export class RunPresenter {
   #prismaClient: PrismaClient;
 
@@ -22,12 +30,14 @@ export class RunPresenter {
     userId,
     projectSlug,
     organizationSlug,
+    environmentSlug,
     runFriendlyId,
     showDeletedLogs,
   }: {
     userId: string;
     projectSlug: string;
     organizationSlug: string;
+    environmentSlug: string;
     runFriendlyId: string;
     showDeletedLogs: boolean;
   }) {
@@ -79,6 +89,12 @@ export class RunPresenter {
       },
     });
 
+    if (environmentSlug !== run.runtimeEnvironment.slug) {
+      throw new RunEnvironmentMismatchError(
+        `Run ${runFriendlyId} is not in environment ${environmentSlug}`
+      );
+    }
+
     const showLogs = showDeletedLogs || !run.logsDeletedAt;
 
     const runData = {

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

@@ -162,6 +162,7 @@ export class ScheduleListPresenter extends BasePresenter {
           },
         },
         active: true,
+        lastRunTriggeredAt: true,
       },
       where: {
         projectId: project.id,
@@ -209,23 +210,7 @@ export class ScheduleListPresenter extends BasePresenter {
       skip: (page - 1) * pageSize,
     });
 
-    const latestRuns =
-      rawSchedules.length > 0
-        ? await this._replica.$queryRaw<{ scheduleId: string; createdAt: Date }[]>`
-    SELECT t."scheduleId", t."createdAt"
-    FROM (
-      SELECT "scheduleId", MAX("createdAt") as "LatestRun"
-      FROM ${sqlDatabaseSchema}."TaskRun"
-      WHERE "scheduleId" IN (${Prisma.join(rawSchedules.map((s) => s.id))})
-      GROUP BY "scheduleId"
-    ) r
-    JOIN ${sqlDatabaseSchema}."TaskRun" t
-    ON t."scheduleId" = r."scheduleId" AND t."createdAt" = r."LatestRun";`
-        : [];
-
     const schedules: ScheduleListItem[] = rawSchedules.map((schedule) => {
-      const latestRun = latestRuns.find((r) => r.scheduleId === schedule.id);
-
       return {
         id: schedule.id,
         type: schedule.type,
@@ -238,7 +223,7 @@ export class ScheduleListPresenter extends BasePresenter {
         timezone: schedule.timezone,
         active: schedule.active,
         externalId: schedule.externalId,
-        lastRun: latestRun?.createdAt,
+        lastRun: schedule.lastRunTriggeredAt ?? undefined,
         nextRun: calculateNextScheduledTimestamp(schedule.generatorExpression, schedule.timezone),
         environments: schedule.instances.map((instance) => {
           const environment = project.environments.find((env) => env.id === instance.environmentId);

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

@@ -18,6 +18,7 @@ import {
   formatDurationMilliseconds,
   millisecondsToNanoseconds,
   nanosecondsToMilliseconds,
+  tryCatch,
 } from "@trigger.dev/core/v3";
 import { type RuntimeEnvironmentType } from "@trigger.dev/database";
 import { motion } from "framer-motion";
@@ -77,7 +78,7 @@ import { useProject } from "~/hooks/useProject";
 import { useReplaceSearchParams } from "~/hooks/useReplaceSearchParams";
 import { type Shortcut, useShortcutKeys } from "~/hooks/useShortcutKeys";
 import { useHasAdminAccess } from "~/hooks/useUser";
-import { RunPresenter } from "~/presenters/v3/RunPresenter.server";
+import { RunEnvironmentMismatchError, RunPresenter } from "~/presenters/v3/RunPresenter.server";
 import { getImpersonationId } from "~/services/impersonation.server";
 import { getResizableSnapshot } from "~/services/resizablePanel.server";
 import { requireUserId } from "~/services/session.server";
@@ -88,12 +89,15 @@ import {
   v3BillingPath,
   v3RunParamsSchema,
   v3RunPath,
+  v3RunRedirectPath,
   v3RunSpanPath,
   v3RunStreamingPath,
   v3RunsPath,
 } from "~/utils/pathBuilder";
 import { useCurrentPlan } from "../_app.orgs.$organizationSlug/route";
 import { SpanView } from "../resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route";
+import { redirectWithErrorMessage } from "~/models/message.server";
+import { redirect } from "remix-typedjson";
 
 const resizableSettings = {
   parent: {
@@ -133,13 +137,30 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const { projectParam, organizationSlug, envParam, runParam } = v3RunParamsSchema.parse(params);
 
   const presenter = new RunPresenter();
-  const result = await presenter.call({
-    userId,
-    organizationSlug,
-    showDeletedLogs: !!impersonationId,
-    projectSlug: projectParam,
-    runFriendlyId: runParam,
-  });
+  const [error, result] = await tryCatch(
+    presenter.call({
+      userId,
+      organizationSlug,
+      showDeletedLogs: !!impersonationId,
+      projectSlug: projectParam,
+      runFriendlyId: runParam,
+      environmentSlug: envParam,
+    })
+  );
+
+  if (error) {
+    if (error instanceof RunEnvironmentMismatchError) {
+      throw redirect(
+        v3RunRedirectPath(
+          { slug: organizationSlug },
+          { slug: projectParam },
+          { friendlyId: runParam }
+        )
+      );
+    }
+
+    throw error;
+  }
 
   //resizable settings
   const parent = await getResizableSnapshot(request, resizableSettings.parent.autosaveId);

apps/webapp/app/utils/pathBuilder.ts

@@ -242,6 +242,14 @@ export function v3RunPath(
   return `${v3RunsPath(organization, project, environment)}/${run.friendlyId}`;
 }
 
+export function v3RunRedirectPath(
+  organization: OrgForPath,
+  project: ProjectForPath,
+  run: v3RunForPath
+) {
+  return `${v3ProjectPath(organization, project)}/runs/${run.friendlyId}`;
+}
+
 export function v3RunDownloadLogsPath(run: v3RunForPath) {
   return `/resources/runs/${run.friendlyId}/logs/download`;
 }

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

@@ -1,4 +1,4 @@
-import { PrismaClientOrTransaction } from "~/db.server";
+import { type PrismaClientOrTransaction } from "~/db.server";
 import { BaseService } from "./baseService.server";
 import { workerQueue } from "~/services/worker.server";
 import { RegisterNextTaskScheduleInstanceService } from "./registerNextTaskScheduleInstance.server";
@@ -147,6 +147,15 @@ export class TriggerScheduledTaskService extends BaseService {
               scheduleInstanceId: instance.id,
             },
           });
+
+          await this._prisma.taskSchedule.update({
+            where: {
+              id: instance.taskSchedule.id,
+            },
+            data: {
+              lastRunTriggeredAt: new Date(),
+            },
+          });
         }
       }
 

internal-packages/database/prisma/migrations/20250327181650_add_last_run_triggered_at_to_task_schedule/migration.sql

@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "TaskSchedule"
+ADD COLUMN "lastRunTriggeredAt" TIMESTAMP(3);

internal-packages/database/prisma/schema.prisma

@@ -2918,6 +2918,8 @@ model TaskSchedule {
   ///Instances of the schedule that are active
   instances TaskScheduleInstance[]
 
+  lastRunTriggeredAt DateTime?
+
   project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade)
   projectId String