perf: batch DB operations in createAttributesScenario to avoid CI timeout (calcom#28320)

* perf: batch DB operations in performance test setup to avoid CI timeout

Replace ~5200 sequential DB inserts with batch createMany() operations
in createHugeAttributesOfTypeSingleSelect. The test was timing out at
60s on 2-vCPU CI runners because the setup phase alone (creating 400
users, 800 memberships, 4000 attribute assignments one-by-one) exceeded
the timeout before the actual logic under test even ran.

Co-Authored-By: romitgabani1 <romitgabani1.work@gmail.com>

* perf: optimize createAttributesScenario with batch DB operations

Move batch DB operations (createMany) into the shared createAttributesScenario
helper so all tests benefit, not just the performance test. Simplify
createHugeAttributesOfTypeSingleSelect to delegate to the optimized helper.

Co-Authored-By: romitgabani1 <romitgabani1.work@gmail.com>

* Revert "perf: optimize createAttributesScenario with batch DB operations"

This reverts commit c739edd.

* Revert "perf: batch DB operations in performance test setup to avoid CI timeout"

This reverts commit ff6642a.

* perf: optimize createAttributesScenario with batch DB operations

Replace sequential prisma.*.create() calls in the shared createAttributesScenario
helper with batch createMany() calls, reducing ~5,200 sequential DB operations to
~10 batch operations. Simplify createHugeAttributesOfTypeSingleSelect to delegate
to the optimized helper instead of duplicating batch logic.

Co-Authored-By: romitgabani1 <romitgabani1.work@gmail.com>

* fix: preserve deterministic user ordering in createAttributesScenario

Map users by email after findMany to ensure the index-based attribute
assignment matches the original userDataList order, since findMany does
not guarantee return order.

Co-Authored-By: romitgabani1 <romitgabani1.work@gmail.com>

* revert: make test timeout back to 1 min

* refactor: extract batch helpers createTestUsers, createTestMembershipsForUsers, createTestAttributeAssignments

Organize batch DB operations from createAttributesScenario into
reusable helper functions mirroring the existing single-record helpers.

Co-Authored-By: romitgabani1 <romitgabani1.work@gmail.com>

* cleanup: remove unused single-record helpers and JSDoc comments

Remove createTestUser, createTestMemberships, createTestAttributeAssignment
(now replaced by batch versions). Remove added comments.

Co-Authored-By: romitgabani1 <romitgabani1.work@gmail.com>

* chore

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: romitg2

packages/features/routing-forms/lib/findTeamMembersMatchingAttributeLogic.integration-test.ts

@@ -53,42 +53,6 @@ const createTestTeam = async (overrides: { parentId: number }) => {
   return team;
 };
 
-const createTestUser = async (overrides?: { email?: string; username?: string }) => {
-  const timestamp = Date.now() + Math.random();
-  const user = await prisma.user.create({
-    data: {
-      email: overrides?.email ?? `test-user-${timestamp}@example.com`,
-      username: overrides?.username ?? `test-user-${timestamp}`,
-    },
-  });
-  createdResources.users.push(user.id);
-  return user;
-};
-
-const createTestMemberships = async (params: { userId: number; orgId: number; teamId: number }) => {
-  const orgMembership = await prisma.membership.create({
-    data: {
-      userId: params.userId,
-      teamId: params.orgId,
-      role: "MEMBER",
-      accepted: true,
-    },
-  });
-  createdResources.memberships.push(orgMembership.id);
-
-  const teamMembership = await prisma.membership.create({
-    data: {
-      userId: params.userId,
-      teamId: params.teamId,
-      role: "MEMBER",
-      accepted: true,
-    },
-  });
-  createdResources.memberships.push(teamMembership.id);
-
-  return { orgMembership, teamMembership };
-};
-
 const createTestAttribute = async (params: {
   orgId: number;
   id: string;
@@ -122,18 +86,98 @@ const createTestAttribute = async (params: {
   return attribute;
 };
 
-const createTestAttributeAssignment = async (params: {
-  orgMembershipId: number;
-  attributeOptionId: string;
+const createTestUsers = async (userDataList: { email: string; username: string }[]) => {
+  await prisma.user.createMany({ data: userDataList });
+
+  const users = await prisma.user.findMany({
+    where: { email: { in: userDataList.map((u) => u.email) } },
+    select: { id: true, email: true },
+  });
+
+  const emailToUser = new Map(users.map((u) => [u.email, u]));
+  const orderedUsers = userDataList.map((ud) => emailToUser.get(ud.email)!);
+
+  createdResources.users.push(...orderedUsers.map((u) => u.id));
+  return orderedUsers;
+};
+
+const createTestMembershipsForUsers = async (params: {
+  userIds: number[];
+  orgId: number;
+  teamId: number;
 }) => {
-  const assignment = await prisma.attributeToUser.create({
-    data: {
-      memberId: params.orgMembershipId,
-      attributeOptionId: params.attributeOptionId,
-    },
+  const { userIds, orgId, teamId } = params;
+
+  await prisma.membership.createMany({
+    data: userIds.map((userId) => ({
+      userId,
+      teamId: orgId,
+      role: "MEMBER" as const,
+      accepted: true,
+    })),
+  });
+
+  const orgMemberships = await prisma.membership.findMany({
+    where: { userId: { in: userIds }, teamId: orgId },
+    select: { id: true, userId: true },
+  });
+
+  createdResources.memberships.push(...orgMemberships.map((m) => m.id));
+
+  await prisma.membership.createMany({
+    data: userIds.map((userId) => ({
+      userId,
+      teamId,
+      role: "MEMBER" as const,
+      accepted: true,
+    })),
   });
-  createdResources.attributeToUsers.push(assignment.id);
-  return assignment;
+
+  const teamMemberships = await prisma.membership.findMany({
+    where: { userId: { in: userIds }, teamId },
+    select: { id: true },
+  });
+
+  createdResources.memberships.push(...teamMemberships.map((m) => m.id));
+
+  const userIdToOrgMembershipId = new Map(orgMemberships.map((m) => [m.userId, m.id]));
+  return { userIdToOrgMembershipId };
+};
+
+const createTestAttributeAssignments = async (params: {
+  orderedUserIds: number[];
+  userIdToOrgMembershipId: Map<number, number>;
+  membersAttributes: Record<string, string | string[]>[];
+  optionValueToId: Map<string, string>;
+}) => {
+  const { orderedUserIds, userIdToOrgMembershipId, membersAttributes, optionValueToId } = params;
+
+  const assignments: { memberId: number; attributeOptionId: string }[] = [];
+  for (let i = 0; i < orderedUserIds.length; i++) {
+    const orgMembershipId = userIdToOrgMembershipId.get(orderedUserIds[i]);
+    if (!orgMembershipId) continue;
+    for (const [attrId, value] of Object.entries(membersAttributes[i])) {
+      const values = Array.isArray(value) ? value : [value];
+      for (const v of values) {
+        const optionId = optionValueToId.get(`${attrId}:${v}`);
+        if (optionId) {
+          assignments.push({ memberId: orgMembershipId, attributeOptionId: optionId });
+        }
+      }
+    }
+  }
+
+  if (assignments.length > 0) {
+    await prisma.attributeToUser.createMany({ data: assignments });
+
+    const orgMembershipIds = Array.from(new Set(assignments.map((a) => a.memberId)));
+    const created = await prisma.attributeToUser.findMany({
+      where: { memberId: { in: orgMembershipIds } },
+      select: { id: true },
+    });
+
+    createdResources.attributeToUsers.push(...created.map((a) => a.id));
+  }
 };
 
 async function createAttributesScenario(params: {
@@ -167,40 +211,33 @@ async function createAttributesScenario(params: {
     }
   }
 
-  const createdUsers: { userId: number; orgMembershipId: number }[] = [];
-
-  for (const member of teamMembersWithAttributeOptionValuePerAttribute) {
-    let userId: number;
-    if (member.userId) {
-      userId = member.userId;
-      const user = await createTestUser();
-      userId = user.id;
-    } else {
-      const user = await createTestUser();
-      userId = user.id;
-    }
+  const numMembers = teamMembersWithAttributeOptionValuePerAttribute.length;
+  const timestamp = Date.now();
 
-    const { orgMembership } = await createTestMemberships({
-      userId,
-      orgId: testFixtures.org.id,
-      teamId: testFixtures.team.id,
-    });
+  const userDataList = Array.from({ length: numMembers }, (_, i) => ({
+    email: `test-user-${timestamp}-${i}@example.com`,
+    username: `test-user-${timestamp}-${i}`,
+  }));
 
-    for (const [attrId, value] of Object.entries(member.attributes)) {
-      const values = Array.isArray(value) ? value : [value];
-      for (const v of values) {
-        const optionId = optionValueToId.get(`${attrId}:${v}`);
-        if (optionId) {
-          await createTestAttributeAssignment({
-            orgMembershipId: orgMembership.id,
-            attributeOptionId: optionId,
-          });
-        }
-      }
-    }
+  const orderedUsers = await createTestUsers(userDataList);
 
-    createdUsers.push({ userId, orgMembershipId: orgMembership.id });
-  }
+  const { userIdToOrgMembershipId } = await createTestMembershipsForUsers({
+    userIds: orderedUsers.map((u) => u.id),
+    orgId: testFixtures.org.id,
+    teamId: testFixtures.team.id,
+  });
+
+  await createTestAttributeAssignments({
+    orderedUserIds: orderedUsers.map((u) => u.id),
+    userIdToOrgMembershipId,
+    membersAttributes: teamMembersWithAttributeOptionValuePerAttribute.map((m) => m.attributes),
+    optionValueToId,
+  });
+
+  const createdUsers = orderedUsers.map((user) => ({
+    userId: user.id,
+    orgMembershipId: userIdToOrgMembershipId.get(user.id)!,
+  }));
 
   return { createdAttributes, createdUsers };
 }
@@ -232,7 +269,7 @@ async function createHugeAttributesOfTypeSingleSelect(params: {
 
   const assignedAttributeOptionIdForEachMember = 1;
 
-  const teamMembersWithAttributeOptionValuePerAttribute = Array.from({ length: numTeamMembers }, (_, i) => ({
+  const teamMembersWithAttributeOptionValuePerAttribute = Array.from({ length: numTeamMembers }, (_, _i) => ({
     attributes: Object.fromEntries(
       Array.from({ length: numAttributesUsedPerTeamMember }, (_, j) => [
         attributes[j].id,