fix(webapp): accept org invites for orgs with many projects

Move dev environment creation out of the membership transaction so accepting
an invite no longer hits the 5s Prisma transaction timeout.

Author: kathiekiwi

.server-changes/fix-invite-accept-many-projects.md

@@ -0,0 +1,8 @@
+---
+area: webapp
+type: fix
+---
+
+Fixed invite acceptance failing for organizations with many projects.
+
+When environment provisioning failed after membership was created, users with a single pending invite were redirected away before seeing the error. They now land on the orgs page with a persistent error toast; users with other pending invites still see a FormError on the invites page.

apps/webapp/app/models/member.server.ts

@@ -1,9 +1,22 @@
-import { type Prisma, prisma } from "~/db.server";
+import type { Organization, OrgMember, Project } from "@trigger.dev/database";
+import { Prisma as PrismaNamespace, type Prisma, prisma } from "~/db.server";
 import { createEnvironment } from "./organization.server";
 import { customAlphabet } from "nanoid";
 import { logger } from "~/services/logger.server";
+import { getDefaultEnvironmentConcurrencyLimit } from "~/services/platform.v3.server";
 import { rbac } from "~/services/rbac.server";
 
+export const INVITE_NOT_FOUND = "Invite not found";
+export const ENV_SETUP_INCOMPLETE =
+  "You joined the organization, but we couldn't finish setting up your development environments. Please try again or contact support if this persists.";
+
+export function isAcceptInviteFormError(error: unknown): error is Error {
+  return (
+    error instanceof Error &&
+    (error.message === INVITE_NOT_FOUND || error.message === ENV_SETUP_INCOMPLETE)
+  );
+}
+
 const tokenValueLength = 40;
 const tokenGenerator = customAlphabet("123456789abcdefghijkmnopqrstuvwxyz", tokenValueLength);
 
@@ -177,65 +190,138 @@ export async function getUsersInvites({ email }: { email: string }) {
   });
 }
 
-export async function acceptInvite({
-  user,
+export async function provisionMemberDevelopmentEnvironments({
   inviteId,
+  user,
+  member,
+  organization,
+  projects,
+  maximumConcurrencyLimit,
 }: {
-  user: { id: string; email: string };
   inviteId: string;
+  user: { id: string; email: string };
+  member: OrgMember;
+  organization: Pick<Organization, "id" | "maximumConcurrencyLimit">;
+  projects: Pick<Project, "id">[];
+  maximumConcurrencyLimit: number;
 }) {
-  const result = await prisma.$transaction(async (tx) => {
-    // 1. Delete the invite and get the invite details
-    const invite = await tx.orgMemberInvite.delete({
-      where: {
-        id: inviteId,
-        email: user.email,
-      },
-      include: {
-        organization: {
-          include: {
-            projects: true,
-          },
-        },
-      },
-    });
+  const projectIds = projects.map((p) => p.id);
+  const createdProjectIds: string[] = [];
+  let failedProjectId: string | undefined;
+  let failedProjectIndex: number | undefined;
 
-    // 2. Join the organization
-    const member = await tx.orgMember.create({
-      data: {
-        organizationId: invite.organizationId,
-        userId: user.id,
-        role: invite.role,
-      },
-    });
+  try {
+    for (const [index, project] of projects.entries()) {
+      failedProjectId = project.id;
+      failedProjectIndex = index;
 
-    // 3. Create an environment for each project
-    for (const project of invite.organization.projects) {
       await createEnvironment({
-        organization: invite.organization,
+        organization,
         project,
         type: "DEVELOPMENT",
         // We set this true but no backfill (yet!?) so never used
         // for dev environments
         isBranchableEnvironment: true,
         member,
-        prismaClient: tx,
+        maximumConcurrencyLimit,
       });
+
+      createdProjectIds.push(project.id);
+      failedProjectId = undefined;
+      failedProjectIndex = undefined;
     }
+  } catch (error) {
+    logger.error("acceptInvite: development environment creation failed after membership created", {
+      inviteId,
+      userId: user.id,
+      organizationId: organization.id,
+      orgMemberId: member.id,
+      projectIds,
+      failedProjectId,
+      failedProjectIndex,
+      totalProjects: projects.length,
+      createdProjectIds,
+      error:
+        error instanceof Error
+          ? { name: error.name, message: error.message, stack: error.stack }
+          : String(error),
+    });
 
-    // 4. Check for other invites
-    const remainingInvites = await tx.orgMemberInvite.findMany({
-      where: {
-        email: user.email,
-      },
+    throw new Error(ENV_SETUP_INCOMPLETE);
+  }
+}
+
+export async function acceptInvite({
+  user,
+  inviteId,
+}: {
+  user: { id: string; email: string };
+  inviteId: string;
+}) {
+  const pendingInvite = await prisma.orgMemberInvite.findFirst({
+    where: { id: inviteId, email: user.email },
+    select: { id: true, organizationId: true },
+  });
+  if (!pendingInvite) {
+    throw new Error(INVITE_NOT_FOUND);
+  }
+
+  const maximumConcurrencyLimit = await getDefaultEnvironmentConcurrencyLimit(
+    pendingInvite.organizationId,
+    "DEVELOPMENT"
+  );
+
+  let result;
+  try {
+    result = await prisma.$transaction(async (tx) => {
+      const invite = await tx.orgMemberInvite.delete({
+        where: {
+          id: inviteId,
+          email: user.email,
+        },
+        include: {
+          organization: {
+            include: {
+              projects: { where: { deletedAt: null } },
+            },
+          },
+        },
+      });
+
+      const member = await tx.orgMember.create({
+        data: {
+          organizationId: invite.organizationId,
+          userId: user.id,
+          role: invite.role,
+        },
+      });
+
+      return {
+        member,
+        organization: invite.organization,
+        rbacRoleId: invite.rbacRoleId,
+      };
     });
+  } catch (error) {
+    if (error instanceof PrismaNamespace.PrismaClientKnownRequestError && error.code === "P2025") {
+      throw new Error(INVITE_NOT_FOUND);
+    }
+    throw error;
+  }
 
-    return {
-      remainingInvites,
-      organization: invite.organization,
-      inviteRole: invite.role,
-      rbacRoleId: invite.rbacRoleId,
-    };
+  await provisionMemberDevelopmentEnvironments({
+    inviteId,
+    user,
+    member: result.member,
+    organization: result.organization,
+    projects: result.organization.projects,
+    maximumConcurrencyLimit,
+  });
+
+  const remainingInvites = await prisma.orgMemberInvite.findMany({
+    where: {
+      email: user.email,
+    },
   });
 
   // If the invite carried an explicit RBAC role, assign it. Best-effort: the
@@ -271,7 +357,7 @@ export async function acceptInvite({
     }
   }
 
-  return { remainingInvites: result.remainingInvites, organization: result.organization };
+  return { remainingInvites, organization: result.organization };
 }
 
 export async function declineInvite({

apps/webapp/app/models/organization.server.ts

@@ -129,20 +129,24 @@ export async function createEnvironment({
   isBranchableEnvironment = false,
   member,
   prismaClient = prisma,
+  /** When set, skips billing lookup — caller must supply the limit for this org + type. */
+  maximumConcurrencyLimit,
 }: {
   organization: Pick<Organization, "id" | "maximumConcurrencyLimit">;
   project: Pick<Project, "id">;
   type: RuntimeEnvironment["type"];
   isBranchableEnvironment?: boolean;
   member?: OrgMember;
   prismaClient?: PrismaClientOrTransaction;
+  maximumConcurrencyLimit?: number;
 }) {
   const slug = envSlug(type);
   const apiKey = createApiKeyForEnv(type);
   const pkApiKey = createPkApiKeyForEnv(type);
   const shortcode = createShortcode().join("-");
 
-  const limit = await getDefaultEnvironmentConcurrencyLimit(organization.id, type);
+  const limit =
+    maximumConcurrencyLimit ?? (await getDefaultEnvironmentConcurrencyLimit(organization.id, type));
   const billingPause = await getInitialEnvPauseStateForBillingLimit(organization.id, type);
 
   const environment = await prismaClient.runtimeEnvironment.create({

apps/webapp/app/routes/invites.tsx

@@ -11,9 +11,16 @@ import { Fieldset } from "~/components/primitives/Fieldset";
 import { FormTitle } from "~/components/primitives/FormTitle";
 import { Header2, Header3 } from "~/components/primitives/Headers";
 import { InputGroup } from "~/components/primitives/InputGroup";
+import { FormError } from "~/components/primitives/FormError";
 import { Paragraph } from "~/components/primitives/Paragraph";
-import { acceptInvite, declineInvite, getUsersInvites } from "~/models/member.server";
-import { redirectWithSuccessMessage } from "~/models/message.server";
+import {
+  acceptInvite,
+  declineInvite,
+  ENV_SETUP_INCOMPLETE,
+  getUsersInvites,
+  isAcceptInviteFormError,
+} from "~/models/member.server";
+import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
 import { requireUser, requireUserId } from "~/services/session.server";
 import { invitesPath, rootPath } from "~/utils/pathBuilder";
 import { EnvelopeIcon } from "@heroicons/react/20/solid";
@@ -80,8 +87,30 @@ export const action: ActionFunction = async ({ request }) => {
         );
       }
     }
-  } catch (error: any) {
-    return json({ errors: { body: error.message } }, { status: 400 });
+  } catch (error) {
+    if (isAcceptInviteFormError(error)) {
+      // Membership was created and the invite deleted before env provisioning
+      // failed. With no invites left, the loader would redirect and discard
+      // a 400 FormError — send the user to orgs with a toast instead.
+      if (error.message === ENV_SETUP_INCOMPLETE) {
+        const remainingInvites = await getUsersInvites({ email: user.email });
+        if (remainingInvites.length === 0) {
+          return redirectWithErrorMessage(rootPath(), request, error.message, {
+            ephemeral: false,
+          });
+        }
+      }
+
+      return json(
+        {
+          intent: submission.intent,
+          payload: submission.payload,
+          error: { __form__: [error.message] },
+        },
+        { status: 400 }
+      );
+    }
+    throw error;
   }
 };
 
@@ -111,6 +140,7 @@ export default function Page() {
               className="mb-0 text-sky-500"
               title={simplur`You have ${invites.length} new invitation[|s]`}
             />
+            <FormError>{form.error}</FormError>
             {invites.map((invite) => (
               <Form key={invite.id} method="post" {...form.props}>
                 <Fieldset>