chore: import upstream snapshot with attribution

2026-07-13 13:32:57 +08:00
commit cd420f9332
4811 changed files with 884702 additions and 0 deletions
@@ -0,0 +1,178 @@
+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 } from "~/v3/regionAccess.server";
+import { BasePresenter } from "./basePresenter.server";
+import { getCurrentPlan } from "~/services/platform.v3.server";
+
+export type Region = {
+  id: string;
+  name: string;
+  masterQueue: string;
+  description?: string;
+  cloudProvider?: string;
+  location?: string;
+  staticIPs?: string | null;
+  isDefault: boolean;
+  isHidden: boolean;
+  workloadType: WorkloadType;
+};
+
+export class RegionsPresenter extends BasePresenter {
+  public async call({
+    userId,
+    projectSlug,
+    isAdmin = false,
+  }: {
+    userId: User["id"];
+    projectSlug: Project["slug"];
+    isAdmin?: boolean;
+  }) {
+    const project = await this._replica.project.findFirst({
+      select: {
+        id: true,
+        organizationId: true,
+        defaultWorkerGroupId: true,
+        allowedWorkerQueues: true,
+        organization: {
+          select: { featureFlags: true },
+        },
+      },
+      where: {
+        slug: projectSlug,
+        organization: {
+          members: {
+            some: {
+              userId,
+            },
+          },
+        },
+      },
+    });
+
+    if (!project) {
+      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 hasComputeAccess = await resolveComputeAccess(
+      this._replica,
+      project.organization.featureFlags
+    );
+
+    const visibleRegions = await this._replica.workerInstanceGroup.findMany({
+      select: {
+        id: true,
+        name: true,
+        masterQueue: true,
+        description: true,
+        cloudProvider: true,
+        location: true,
+        staticIPs: true,
+        hidden: true,
+        workloadType: true,
+      },
+      where: isAdmin
+        ? undefined
+        : // Hide hidden unless they're allowed to use them
+          project.allowedWorkerQueues.length > 0
+          ? {
+              masterQueue: { in: project.allowedWorkerQueues },
+            }
+          : defaultVisibilityFilter(hasComputeAccess),
+      orderBy: {
+        name: "asc",
+      },
+    });
+
+    const regions: Region[] = visibleRegions.map((region) => ({
+      id: region.id,
+      name: region.name,
+      masterQueue: region.masterQueue,
+      description: region.description ?? undefined,
+      cloudProvider: region.cloudProvider ?? undefined,
+      location: region.location ?? undefined,
+      staticIPs: region.staticIPs ?? undefined,
+      isDefault: region.id === defaultWorkerInstanceGroupId,
+      isHidden: region.hidden,
+      workloadType: region.workloadType,
+    }));
+
+    if (project.defaultWorkerGroupId) {
+      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: project.defaultWorkerGroupId },
+      });
+
+      if (defaultWorkerGroup) {
+        // Unset the default region
+        const defaultRegion = regions.find((region) => region.isDefault);
+        if (defaultRegion) {
+          defaultRegion.isDefault = false;
+        }
+
+        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
+    const sorted = regions.sort((a, b) => {
+      if (a.isDefault) return -1;
+      if (b.isDefault) return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    // Remove later duplicates
+    let unique = sorted.filter((region, index, self) => {
+      const firstIndex = self.findIndex((t) => t.id === region.id);
+      return index === firstIndex;
+    });
+
+    // Don't show static IPs for free users
+    // Even if they had the IPs they wouldn't work, but this makes it less confusing
+    const currentPlan = await getCurrentPlan(project.organizationId);
+    const isPaying = currentPlan?.v3Subscription.isPaying === true;
+    if (!isPaying) {
+      unique = unique.map((region) => ({
+        ...region,
+        staticIPs: region.staticIPs ? null : undefined,
+      }));
+    }
+
+    return {
+      regions: unique.sort((a, b) => a.name.localeCompare(b.name)),
+      isPaying,
+    };
+  }
+}