feat(webapp): add compute migration resolver

Author: nicktrn

apps/webapp/app/runEngine/concerns/computeMigration.server.ts

@@ -0,0 +1,90 @@
+import { hashBucket } from "~/utils/computeBucket";
+
+/** Subset of the global flags snapshot this resolver reads. */
+export type ComputeMigrationFlags = {
+  computeMigrationEnabled?: boolean;
+  computeMigrationFreePercentage?: number;
+  computeMigrationPaidPercentage?: number;
+};
+
+export type ComputeBackingMap = Record<string, string>;
+
+/**
+ * Parse COMPUTE_BACKING_MAP (container-region masterQueue -> compute-backing
+ * masterQueue). Never throws: bad JSON or non-string values yield {} so a
+ * misconfigured env disables migration rather than breaking triggers.
+ */
+export function parseComputeBackingMap(raw: string): ComputeBackingMap {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return {};
+    const out: ComputeBackingMap = {};
+    for (const [k, v] of Object.entries(parsed)) {
+      if (typeof v === "string") out[k] = v;
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+type MigrationDecisionInput = {
+  planType: string | undefined;
+  orgId: string;
+  orgFeatureFlags: Record<string, unknown> | null | undefined;
+  flags: ComputeMigrationFlags | undefined;
+};
+
+/**
+ * Whether this org should run on the compute backing. Shared by the trigger-time
+ * transform and the deploy-time template decision so a migrated org always gets a
+ * compute template. Precedence: per-org override (both directions) wins; otherwise
+ * global enable + the plan's percentage bucket. Enterprise and unknown plans are
+ * never enrolled by percentage (override only). The sole opt-out is the per-org
+ * `computeMigrationEnabled: false`.
+ */
+export function isOrgMigrated({
+  planType,
+  orgId,
+  orgFeatureFlags,
+  flags,
+}: MigrationDecisionInput): boolean {
+  const override = orgFeatureFlags?.["computeMigrationEnabled"];
+  if (override === false) return false;
+  if (override === true) return true;
+
+  if (!(flags?.computeMigrationEnabled ?? false)) return false;
+
+  const pct =
+    planType === "free"
+      ? flags?.computeMigrationFreePercentage ?? 0
+      : planType === "paid"
+      ? flags?.computeMigrationPaidPercentage ?? 0
+      : 0; // enterprise / undefined
+
+  return hashBucket(orgId) < pct;
+}
+
+type ResolveInput = MigrationDecisionInput & {
+  baseWorkerQueue: string | undefined;
+  envType: string;
+  backingMap: ComputeBackingMap;
+};
+
+/**
+ * Rewrite the resolved worker queue to its compute backing when the org is
+ * migrated and the region has a backing. Same-geo swap (us-east-1 -> us-east-1-next):
+ * any explicit placement is a geography preference, honored by staying in-region.
+ * Applied after region resolution, mirroring the scheduled-split.
+ */
+export function resolveComputeMigration({
+  baseWorkerQueue,
+  envType,
+  backingMap,
+  ...decision
+}: ResolveInput): string | undefined {
+  if (baseWorkerQueue === undefined) return baseWorkerQueue;
+  if (envType === "DEVELOPMENT") return baseWorkerQueue;
+  if (!isOrgMigrated(decision)) return baseWorkerQueue;
+  return backingMap[baseWorkerQueue] ?? baseWorkerQueue;
+}

apps/webapp/test/computeMigration.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest";
+import {
+  parseComputeBackingMap,
+  isOrgMigrated,
+  resolveComputeMigration,
+} from "~/runEngine/concerns/computeMigration.server";
+
+const BACKING = { "us-east-1": "us-east-1-next" };
+
+describe("parseComputeBackingMap", () => {
+  it("parses valid JSON", () => {
+    expect(parseComputeBackingMap('{"us-east-1":"us-east-1-next"}')).toEqual(BACKING);
+  });
+  it("returns {} on invalid JSON without throwing", () => {
+    expect(parseComputeBackingMap("not json")).toEqual({});
+  });
+  it("returns {} on non-string values", () => {
+    expect(parseComputeBackingMap('{"us-east-1":5}')).toEqual({});
+  });
+});
+
+describe("isOrgMigrated", () => {
+  const base = {
+    planType: "free" as string | undefined,
+    orgFeatureFlags: {} as Record<string, unknown>,
+    flags: { computeMigrationEnabled: true, computeMigrationFreePercentage: 100 },
+  };
+
+  it("migrates a free org at 100%", () => {
+    expect(isOrgMigrated({ ...base, orgId: "org_x" })).toBe(true);
+  });
+  it("does not migrate when globally disabled", () => {
+    expect(
+      isOrgMigrated({ ...base, orgId: "org_x", flags: { computeMigrationEnabled: false, computeMigrationFreePercentage: 100 } })
+    ).toBe(false);
+  });
+  it("per-org override false excludes even at 100%", () => {
+    expect(
+      isOrgMigrated({ ...base, orgId: "org_x", orgFeatureFlags: { computeMigrationEnabled: false } })
+    ).toBe(false);
+  });
+  it("per-org override true enrolls even when globally off", () => {
+    expect(
+      isOrgMigrated({
+        ...base,
+        orgId: "org_x",
+        orgFeatureFlags: { computeMigrationEnabled: true },
+        flags: { computeMigrationEnabled: false, computeMigrationFreePercentage: 0 },
+      })
+    ).toBe(true);
+  });
+  it("paid uses the paid dial", () => {
+    expect(
+      isOrgMigrated({
+        planType: "paid",
+        orgId: "org_x",
+        orgFeatureFlags: {},
+        flags: { computeMigrationEnabled: true, computeMigrationPaidPercentage: 100 },
+      })
+    ).toBe(true);
+  });
+  it("enterprise is never enrolled by percentage", () => {
+    expect(
+      isOrgMigrated({
+        planType: "enterprise",
+        orgId: "org_x",
+        orgFeatureFlags: {},
+        flags: { computeMigrationEnabled: true, computeMigrationFreePercentage: 100, computeMigrationPaidPercentage: 100 },
+      })
+    ).toBe(false);
+  });
+  it("undefined planType is not enrolled", () => {
+    expect(
+      isOrgMigrated({ planType: undefined, orgId: "org_x", orgFeatureFlags: {}, flags: { computeMigrationEnabled: true } })
+    ).toBe(false);
+  });
+});
+
+describe("resolveComputeMigration", () => {
+  const enrolled = {
+    planType: "free",
+    orgFeatureFlags: {},
+    flags: { computeMigrationEnabled: true, computeMigrationFreePercentage: 100 },
+    envType: "PRODUCTION",
+    backingMap: BACKING,
+  };
+
+  it("swaps to the compute backing for an enrolled free org", () => {
+    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x" }))
+      .toBe("us-east-1-next");
+  });
+  it("leaves a region with no backing untouched (EU)", () => {
+    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: "eu-central-1", orgId: "org_x" }))
+      .toBe("eu-central-1");
+  });
+  it("does not migrate DEVELOPMENT", () => {
+    expect(
+      resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x", envType: "DEVELOPMENT" })
+    ).toBe("us-east-1");
+  });
+  it("leaves a non-enrolled org untouched", () => {
+    expect(
+      resolveComputeMigration({ ...enrolled, baseWorkerQueue: "us-east-1", orgId: "org_x", flags: { computeMigrationEnabled: false } })
+    ).toBe("us-east-1");
+  });
+  it("undefined baseWorkerQueue passes through", () => {
+    expect(resolveComputeMigration({ ...enrolled, baseWorkerQueue: undefined, orgId: "org_x" }))
+      .toBeUndefined();
+  });
+});