feat(database,webapp): add WorkerInstanceGroup.region + worker-region registry

Author: nicktrn

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

@@ -0,0 +1,60 @@
+import { type WorkloadType } from "@trigger.dev/database";
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { singleton } from "~/utils/singleton";
+import { createReloadingRegistry } from "~/utils/reloadingRegistry.server";
+
+export type WorkerGroupRegionRow = {
+  masterQueue: string;
+  region: string | null;
+  workloadType: WorkloadType;
+  hidden: boolean;
+};
+
+/**
+ * Reverse map: a stored worker queue -> its user-facing geo region. A backing
+ * queue (e.g. "us-east-1-next") returns the region it backs ("us-east-1");
+ * anything unknown or with no region set passes through unchanged (so container
+ * queues and not-yet-labelled groups behave exactly as before).
+ */
+export function regionForQueue(queue: string, groups: WorkerGroupRegionRow[]): string {
+  const self = groups.find((g) => g.masterQueue === queue);
+  return self?.region ?? queue;
+}
+
+/**
+ * Forward map: the compute (MICROVM) backing queue for the region that `queue`
+ * belongs to, or undefined if the region has no compute backing. `queue` is the
+ * resolved (container) worker queue; we look up its region, then find a visible
+ * MICROVM group in the same region.
+ */
+export function backingForQueue(queue: string, groups: WorkerGroupRegionRow[]): string | undefined {
+  const self = groups.find((g) => g.masterQueue === queue);
+  const region = self?.region;
+  if (!region) return undefined;
+  const backing = groups.find(
+    (g) =>
+      g.workloadType === "MICROVM" &&
+      g.region === region &&
+      !g.hidden &&
+      g.masterQueue !== queue
+  );
+  return backing?.masterQueue;
+}
+
+/**
+ * In-memory snapshot of every worker group's (queue, region, type, hidden),
+ * refreshed on an interval. Read synchronously on the hot path; callers gate the
+ * first read on `waitUntilReady`. Replaces the COMPUTE_BACKING_MAP env var as the
+ * source of truth for region<->backing resolution.
+ */
+export const workerRegionRegistry = singleton("workerRegionRegistry", () =>
+  createReloadingRegistry<WorkerGroupRegionRow[]>({
+    name: "worker-region",
+    intervalMs: env.GLOBAL_FLAGS_RELOAD_INTERVAL_MS,
+    load: () =>
+      prisma.workerInstanceGroup.findMany({
+        select: { masterQueue: true, region: true, workloadType: true, hidden: true },
+      }),
+  })
+);

apps/webapp/test/workerRegions.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { regionForQueue, backingForQueue, type WorkerGroupRegionRow } from "~/v3/workerRegions.server";
+
+const groups: WorkerGroupRegionRow[] = [
+  { masterQueue: "us-east-1", region: "us-east-1", workloadType: "CONTAINER", hidden: false },
+  { masterQueue: "us-east-1-next", region: "us-east-1", workloadType: "MICROVM", hidden: false },
+  { masterQueue: "eu-central-1", region: "eu-central-1", workloadType: "CONTAINER", hidden: false },
+];
+
+describe("regionForQueue", () => {
+  it("maps a backing queue to its region", () => {
+    expect(regionForQueue("us-east-1-next", groups)).toBe("us-east-1");
+  });
+  it("maps a container queue to its own region", () => {
+    expect(regionForQueue("us-east-1", groups)).toBe("us-east-1");
+  });
+  it("passes an unknown queue through unchanged", () => {
+    expect(regionForQueue("mystery", groups)).toBe("mystery");
+  });
+  it("passes through when a group has no region set", () => {
+    expect(regionForQueue("x", [{ masterQueue: "x", region: null, workloadType: "CONTAINER", hidden: false }])).toBe("x");
+  });
+});
+
+describe("backingForQueue", () => {
+  it("finds the MICROVM backing for a region with one", () => {
+    expect(backingForQueue("us-east-1", groups)).toBe("us-east-1-next");
+  });
+  it("returns undefined for a region with no compute backing (EU)", () => {
+    expect(backingForQueue("eu-central-1", groups)).toBeUndefined();
+  });
+  it("returns undefined when the queue's group has no region", () => {
+    expect(backingForQueue("x", [{ masterQueue: "x", region: null, workloadType: "CONTAINER", hidden: false }])).toBeUndefined();
+  });
+  it("ignores hidden MICROVM groups", () => {
+    const g: WorkerGroupRegionRow[] = [
+      { masterQueue: "us-east-1", region: "us-east-1", workloadType: "CONTAINER", hidden: false },
+      { masterQueue: "us-east-1-next", region: "us-east-1", workloadType: "MICROVM", hidden: true },
+    ];
+    expect(backingForQueue("us-east-1", g)).toBeUndefined();
+  });
+});

internal-packages/database/prisma/migrations/20260615210000_add_worker_instance_group_region/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "WorkerInstanceGroup" ADD COLUMN IF NOT EXISTS "region" TEXT;

internal-packages/database/prisma/schema.prisma

@@ -1532,6 +1532,10 @@ model WorkerInstanceGroup {
 
   workloadType WorkloadType @default(CONTAINER)
 
+  /// Geo region (e.g. "us-east-1"); container + MICROVM groups for one geo share it.
+  /// Set-once while the group has runs - changing it breaks region resolution for them.
+  region String?
+
   /// When true, runs enqueued to this worker queue may skip the intermediate queue
   /// and be pushed directly to the worker queue when concurrency is available.
   enableFastPath Boolean @default(false)