refactor(webapp): resolve regions UI default via canonical resolver

RegionsPresenter now resolves the effective default through
getDefaultWorkerGroupForProject (existence-checked env -> project -> global),
so the UI default always matches where runs route and never points at a
deleted region. Removes the id-only resolveEffectiveDefaultWorkerGroupId
helper (and its test) now that all four sites share one resolver.

Author: myftija

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

@@ -1,13 +1,8 @@
 import { type WorkloadType } from "@trigger.dev/database";
 import { type Project } from "~/models/project.server";
 import { type User } from "~/models/user.server";
-import { FEATURE_FLAG } from "~/v3/featureFlags";
-import { makeFlag } from "~/v3/featureFlags.server";
-import {
-  defaultVisibilityFilter,
-  resolveComputeAccess,
-  resolveEffectiveDefaultWorkerGroupId,
-} from "~/v3/regionAccess.server";
+import { defaultVisibilityFilter, resolveComputeAccess } from "~/v3/regionAccess.server";
+import { WorkerGroupService } from "~/v3/services/worker/workerGroupService.server";
 import { BasePresenter } from "./basePresenter.server";
 import { getCurrentPlan } from "~/services/platform.v3.server";
 
@@ -40,7 +35,6 @@ export class RegionsPresenter extends BasePresenter {
       select: {
         id: true,
         organizationId: true,
-        defaultWorkerGroupId: true,
         allowedWorkerQueues: true,
         organization: {
           select: { featureFlags: true },
@@ -62,28 +56,21 @@ export class RegionsPresenter extends BasePresenter {
       throw new Error("Project not found");
     }
 
-    const getFlag = makeFlag(this._replica);
-    const defaultWorkerInstanceGroupId = await getFlag({
-      key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
-    });
-
-    if (!defaultWorkerInstanceGroupId) {
-      throw new Error("Default worker instance group not found");
-    }
-
     const environment = environmentId
       ? await this._replica.runtimeEnvironment.findFirst({
           select: { defaultWorkerGroupId: true },
           where: { id: environmentId, projectId: project.id, archivedAt: null },
         })
       : null;
 
-    // env default -> project default -> global default
-    const effectiveDefaultId = resolveEffectiveDefaultWorkerGroupId({
+    // Resolve via the same path the trigger uses (env -> project -> global, each
+    // existence-checked) so the UI default always matches where runs route and can
+    // never point at a deleted region.
+    const defaultWorkerGroup = await new WorkerGroupService().getDefaultWorkerGroupForProject({
+      projectId: project.id,
       environmentDefaultWorkerGroupId: environment?.defaultWorkerGroupId,
-      projectDefaultWorkerGroupId: project.defaultWorkerGroupId,
-      globalDefaultWorkerGroupId: defaultWorkerInstanceGroupId,
     });
+    const effectiveDefaultId = defaultWorkerGroup?.id;
 
     const hasComputeAccess = await resolveComputeAccess(
       this._replica,
@@ -128,38 +115,21 @@ export class RegionsPresenter extends BasePresenter {
       workloadType: region.workloadType,
     }));
 
-    // The effective default may not be in the visible list (e.g. a hidden
-    // region set as the env/project default) — fetch and include it.
-    if (effectiveDefaultId && !regions.some((region) => region.id === effectiveDefaultId)) {
-      const defaultWorkerGroup = await this._replica.workerInstanceGroup.findFirst({
-        select: {
-          id: true,
-          name: true,
-          masterQueue: true,
-          description: true,
-          cloudProvider: true,
-          location: true,
-          staticIPs: true,
-          hidden: true,
-          workloadType: true,
-        },
-        where: { id: effectiveDefaultId },
+    // The default may not be in the visible list (e.g. a hidden region set as the
+    // env/project default) — include the already-resolved group so it still shows.
+    if (defaultWorkerGroup && !regions.some((region) => region.id === defaultWorkerGroup.id)) {
+      regions.push({
+        id: defaultWorkerGroup.id,
+        name: defaultWorkerGroup.name,
+        masterQueue: defaultWorkerGroup.masterQueue,
+        description: defaultWorkerGroup.description ?? undefined,
+        cloudProvider: defaultWorkerGroup.cloudProvider ?? undefined,
+        location: defaultWorkerGroup.location ?? undefined,
+        staticIPs: defaultWorkerGroup.staticIPs ?? undefined,
+        isDefault: true,
+        isHidden: defaultWorkerGroup.hidden,
+        workloadType: defaultWorkerGroup.workloadType,
       });
-
-      if (defaultWorkerGroup) {
-        regions.push({
-          id: defaultWorkerGroup.id,
-          name: defaultWorkerGroup.name,
-          masterQueue: defaultWorkerGroup.masterQueue,
-          description: defaultWorkerGroup.description ?? undefined,
-          cloudProvider: defaultWorkerGroup.cloudProvider ?? undefined,
-          location: defaultWorkerGroup.location ?? undefined,
-          staticIPs: defaultWorkerGroup.staticIPs ?? undefined,
-          isDefault: true,
-          isHidden: defaultWorkerGroup.hidden,
-          workloadType: defaultWorkerGroup.workloadType,
-        });
-      }
     }
 
     // Default first

apps/webapp/app/v3/regionAccess.server.ts

@@ -33,29 +33,6 @@ export function defaultVisibilityFilter(
   return { hidden: false, workloadType: { not: "MICROVM" } };
 }
 
-/**
- * Canonical fallback chain for a run's default region:
- * environment default -> project default -> global default.
- * Both the trigger path and the regions UI must use this order so the
- * displayed default matches what actually runs.
- */
-export function resolveEffectiveDefaultWorkerGroupId({
-  environmentDefaultWorkerGroupId,
-  projectDefaultWorkerGroupId,
-  globalDefaultWorkerGroupId,
-}: {
-  environmentDefaultWorkerGroupId?: string | null;
-  projectDefaultWorkerGroupId?: string | null;
-  globalDefaultWorkerGroupId?: string | null;
-}): string | undefined {
-  return (
-    environmentDefaultWorkerGroupId ??
-    projectDefaultWorkerGroupId ??
-    globalDefaultWorkerGroupId ??
-    undefined
-  );
-}
-
 /**
  * Whether a region is accessible given compute access.
  * MICROVM regions require compute access; all other types pass through.

apps/webapp/app/v3/services/worker/workerGroupService.server.ts

@@ -284,8 +284,9 @@ export class WorkerGroupService extends WithRunEngine {
       return workerGroup;
     }
 
-    // Resolution order must match resolveEffectiveDefaultWorkerGroupId:
-    // environment default -> project default -> global default.
+    // Canonical default-region resolution (reused by the regions UI, workers API
+    // and compute templates): environment default -> project default -> global
+    // default, each existence-checked so a deleted region falls through.
     if (environmentDefaultWorkerGroupId) {
       const envWorkerGroup = await this._prisma.workerInstanceGroup.findFirst({
         where: { id: environmentDefaultWorkerGroupId },