fix(webapp): scope development branches to each member

Author: carderne

apps/webapp/app/services/upsertBranch.server.ts

@@ -1,4 +1,8 @@
-import { type PrismaClient, type PrismaClientOrTransaction } from "@trigger.dev/database";
+import {
+  type Prisma,
+  type PrismaClient,
+  type PrismaClientOrTransaction,
+} from "@trigger.dev/database";
 import slug from "slug";
 import { prisma } from "~/db.server";
 import { createApiKeyForEnv, createPkApiKeyForEnv } from "~/models/api-key.server";
@@ -13,6 +17,7 @@ import { logger } from "./logger.server";
 import { getCurrentPlan, getLimit } from "./platform.v3.server";
 import { type z } from "zod";
 import invariant from "tiny-invariant";
+import { nanoid } from "nanoid";
 import { type CreateBranchOptions } from "~/utils/branches";
 import {
   applyBillingLimitPauseAfterEnvCreate,
@@ -141,20 +146,36 @@ export class UpsertBranchService {
       const branchSlug = `${slug(`${parentEnvironment.slug}-${sanitizedBranchName}`)}`;
       const apiKey = createApiKeyForEnv(parentEnvironment.type);
       const pkApiKey = createPkApiKeyForEnv(parentEnvironment.type);
-      const shortcode = branchSlug;
+      const isDevelopmentBranch = parentEnvironment.type === "DEVELOPMENT";
+      // Dev branch slugs are member-scoped, but shortcodes remain project-scoped.
+      // Keep the readable slug while giving each member's branch a unique shortcode.
+      const shortcode = isDevelopmentBranch ? `${branchSlug}-${nanoid()}` : branchSlug;
+      let branchWhere: Prisma.RuntimeEnvironmentWhereUniqueInput;
+      if (isDevelopmentBranch) {
+        invariant(parentEnvironment.orgMemberId, "Development branches require an org member");
+        branchWhere = {
+          projectId_slug_orgMemberId: {
+            projectId: parentEnvironment.project.id,
+            slug: branchSlug,
+            orgMemberId: parentEnvironment.orgMemberId,
+          },
+        };
+      } else {
+        branchWhere = {
+          projectId_shortcode: {
+            projectId: parentEnvironment.project.id,
+            shortcode,
+          },
+        };
+      }
       const billingPause = await getInitialEnvPauseStateForBillingLimit(
         parentEnvironment.organization.id,
         parentEnvironment.type
       );
 
       const now = new Date();
       const branch = await this.#prismaClient.runtimeEnvironment.upsert({
-        where: {
-          projectId_shortcode: {
-            projectId: parentEnvironment.project.id,
-            shortcode: shortcode,
-          },
-        },
+        where: branchWhere,
         create: {
           slug: branchSlug,
           apiKey,

apps/webapp/test/devBranchServices.test.ts

@@ -4,7 +4,11 @@ import slug from "slug";
 import { describe, expect, vi } from "vitest";
 import { ArchiveBranchService } from "~/services/archiveBranch.server";
 import { UpsertBranchService } from "~/services/upsertBranch.server";
-import { createTestOrgProjectWithMember, uniqueId } from "./fixtures/environmentVariablesFixtures";
+import {
+  createTestOrgProjectWithMember,
+  createTestUser,
+  uniqueId,
+} from "./fixtures/environmentVariablesFixtures";
 
 vi.setConfig({ testTimeout: 60_000 });
 
@@ -77,6 +81,61 @@ describe("UpsertBranchService — DEVELOPMENT parent", () => {
     }
   );
 
+  postgresTest("allows different members to use the same branch name", async ({ prisma }) => {
+    const {
+      organization,
+      project,
+      user: firstUser,
+      orgMember: firstMember,
+    } = await createTestOrgProjectWithMember(prisma);
+    const secondUser = await createTestUser(prisma);
+    const secondMember = await prisma.orgMember.create({
+      data: {
+        organizationId: organization.id,
+        userId: secondUser.id,
+        role: "MEMBER",
+      },
+    });
+
+    await Promise.all([
+      createDevRoot(prisma, project.id, organization.id, firstMember.id),
+      createDevRoot(prisma, project.id, organization.id, secondMember.id),
+    ]);
+
+    const options = {
+      projectId: project.id,
+      env: "development" as const,
+      branchName: "shared-name",
+    };
+    const [firstResult, secondResult] = await Promise.all([
+      new UpsertBranchService(prisma).call(
+        { type: "userMembership", userId: firstUser.id },
+        options
+      ),
+      new UpsertBranchService(prisma).call(
+        { type: "userMembership", userId: secondUser.id },
+        options
+      ),
+    ]);
+
+    expect(firstResult.success && secondResult.success).toBe(true);
+    if (!firstResult.success || !secondResult.success) return;
+    expect(firstResult.branch.id).not.toBe(secondResult.branch.id);
+    expect(firstResult.branch.slug).toBe(secondResult.branch.slug);
+    expect(firstResult.branch.shortcode).not.toBe(secondResult.branch.shortcode);
+    expect(firstResult.branch.orgMemberId).toBe(firstMember.id);
+    expect(secondResult.branch.orgMemberId).toBe(secondMember.id);
+
+    const firstRetry = await new UpsertBranchService(prisma).call(
+      { type: "userMembership", userId: firstUser.id },
+      options
+    );
+    expect(firstRetry.success).toBe(true);
+    if (!firstRetry.success) return;
+    expect(firstRetry.alreadyExisted).toBe(true);
+    expect(firstRetry.branch.id).toBe(firstResult.branch.id);
+  });
+
   postgresTest(
     "rejects an invalid branch name without touching the database",
     async ({ prisma }) => {