feat(webapp): write default region to the environment

SetDefaultRegionService now sets RuntimeEnvironment.defaultWorkerGroupId
(allowlist checks stay project-scoped). Regions route resolves the env in
its loader and action.

Author: myftija

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

@@ -52,26 +52,37 @@ import { useOrganization } from "~/hooks/useOrganizations";
 import { useHasAdminAccess } from "~/hooks/useUser";
 import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
 import { findProjectBySlug } from "~/models/project.server";
+import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
 import { type Region, RegionsPresenter } from "~/presenters/v3/RegionsPresenter.server";
 import { requireUser } from "~/services/session.server";
 import {
   docsPath,
   EnvironmentParamSchema,
-  ProjectParamSchema,
   regionsPath,
   v3BillingPath,
 } from "~/utils/pathBuilder";
 import { SetDefaultRegionService } from "~/v3/services/setDefaultRegion.server";
 
 export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const user = await requireUser(request);
-  const { projectParam } = ProjectParamSchema.parse(params);
+  const { organizationSlug, projectParam, envParam } = EnvironmentParamSchema.parse(params);
+
+  const project = await findProjectBySlug(organizationSlug, projectParam, user.id);
+  if (!project) {
+    throw new Response(undefined, { status: 404, statusText: "Project not found" });
+  }
+
+  const environment = await findEnvironmentBySlug(project.id, envParam, user.id);
+  if (!environment) {
+    throw new Response(undefined, { status: 404, statusText: "Environment not found" });
+  }
 
   const presenter = new RegionsPresenter();
   const [error, result] = await tryCatch(
     presenter.call({
       userId: user.id,
       projectSlug: projectParam,
+      environmentId: environment.id,
       isAdmin: user.admin || user.isImpersonating,
     })
   );
@@ -106,6 +117,11 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
     throw redirectWithErrorMessage(redirectPath, request, "Project not found");
   }
 
+  const environment = await findEnvironmentBySlug(project.id, envParam, user.id);
+  if (!environment) {
+    throw redirectWithErrorMessage(redirectPath, request, "Environment not found");
+  }
+
   const formData = await request.formData();
   const parsedFormData = FormSchema.safeParse(Object.fromEntries(formData));
 
@@ -116,7 +132,7 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
   const service = new SetDefaultRegionService();
   const [error, result] = await tryCatch(
     service.call({
-      projectId: project.id,
+      environmentId: environment.id,
       regionId: parsedFormData.data.regionId,
       isAdmin: user.admin || user.isImpersonating,
     })

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

@@ -3,11 +3,11 @@ import { BaseService, ServiceValidationError } from "./baseService.server";
 
 export class SetDefaultRegionService extends BaseService {
   public async call({
-    projectId,
+    environmentId,
     regionId,
     isAdmin = false,
   }: {
-    projectId: string;
+    environmentId: string;
     regionId: string;
     isAdmin?: boolean;
   }) {
@@ -21,23 +21,25 @@ export class SetDefaultRegionService extends BaseService {
       throw new ServiceValidationError("Region not found");
     }
 
-    const project = await this._prisma.project.findFirst({
+    const environment = await this._prisma.runtimeEnvironment.findFirst({
       where: {
-        id: projectId,
+        id: environmentId,
       },
-      include: {
+      select: {
+        id: true,
+        project: { select: { allowedWorkerQueues: true } },
         organization: { select: { featureFlags: true } },
       },
     });
 
-    if (!project) {
-      throw new ServiceValidationError("Project not found");
+    if (!environment) {
+      throw new ServiceValidationError("Environment not found");
     }
 
-    // If their project is restricted, only allow them to set default regions that are allowed
+    // The allowlist stays project-scoped; only the default moves to the environment.
     if (!isAdmin) {
-      if (project.allowedWorkerQueues.length > 0) {
-        if (!project.allowedWorkerQueues.includes(workerGroup.masterQueue)) {
+      if (environment.project.allowedWorkerQueues.length > 0) {
+        if (!environment.project.allowedWorkerQueues.includes(workerGroup.masterQueue)) {
           throw new ServiceValidationError("You're not allowed to set this region as default");
         }
       } else {
@@ -48,7 +50,7 @@ export class SetDefaultRegionService extends BaseService {
         if (workerGroup.workloadType === "MICROVM") {
           const hasComputeAccess = await resolveComputeAccess(
             this._prisma,
-            project.organization.featureFlags
+            environment.organization.featureFlags
           );
 
           if (!isComputeRegionAccessible(workerGroup, hasComputeAccess)) {
@@ -58,9 +60,9 @@ export class SetDefaultRegionService extends BaseService {
       }
     }
 
-    await this._prisma.project.update({
+    await this._prisma.runtimeEnvironment.update({
       where: {
-        id: projectId,
+        id: environmentId,
       },
       data: {
         defaultWorkerGroupId: regionId,