feat: adds user plan info in useHasPaidPlan for intercom

apps/web/app/api/support/conversation/route.ts

@@ -3,11 +3,13 @@ import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
 
 import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
+import { BillingPlanService } from "@calcom/features/ee/billing/domain/billing-plans";
 import type { Contact } from "@calcom/features/ee/support/lib/intercom/intercom";
 import { intercom } from "@calcom/features/ee/support/lib/intercom/intercom";
 import { WEBAPP_URL, WEBSITE_URL } from "@calcom/lib/constants";
 import logger from "@calcom/lib/logger";
 import { safeStringify } from "@calcom/lib/safeStringify";
+import { MembershipRepository } from "@calcom/lib/server/repository/membership";
 import { UserRepository } from "@calcom/lib/server/repository/user";
 import prisma from "@calcom/prisma";
 
@@ -43,6 +45,9 @@ export async function POST(req: NextRequest) {
 
   const { user } = session;
 
+  const memberships = await MembershipRepository.findAllMembershipsByUserIdForBilling({ userId: user.id });
+  const billingPlanService = new BillingPlanService();
+  const plan = await billingPlanService.getUserPlanByMemberships(memberships);
   if (!existingContact.data) {
     const additionalUserInfo = await new UserRepository(prisma).getUserStats({ userId: session.user.id });
     const sumOfTeamEventTypes = additionalUserInfo?.teams.reduce(
@@ -72,6 +77,7 @@ export async function POST(req: NextRequest) {
         sum_of_teams: additionalUserInfo?._count?.teams,
         sum_of_event_types: additionalUserInfo?._count?.eventTypes,
         sum_of_team_event_types: sumOfTeamEventTypes,
+        Plan: plan,
       },
     });
 

apps/web/app/api/teams/[team]/upgrade/route.ts

@@ -11,7 +11,9 @@ import { getServerSession } from "@calcom/features/auth/lib/getServerSession";
 import stripe from "@calcom/features/ee/payments/server/stripe";
 import { WEBAPP_URL } from "@calcom/lib/constants";
 import { HttpError } from "@calcom/lib/http-error";
-import prisma from "@calcom/prisma";
+import { TeamRepository } from "@calcom/lib/server/repository/team";
+import { prisma } from "@calcom/prisma";
+import { Plans } from "@calcom/prisma/enums";
 import { teamMetadataStrictSchema } from "@calcom/prisma/zod-utils";
 
 import { buildLegacyRequest } from "@lib/buildLegacyCtx";
@@ -41,23 +43,24 @@ async function getHandler(req: NextRequest, { params }: { params: Promise<Params
       throw new HttpError({ statusCode: 402, message: "Payment required" });
     }
 
-    let team = await prisma.team.findFirst({
-      where: { metadata: { path: ["paymentId"], equals: checkoutSession.id } },
-    });
+    const teamRepository = new TeamRepository(prisma);
+    let team = await teamRepository.findFirstByMetadataPaymentId({ paymentId: checkoutSession.id });
 
     let metadata;
 
     if (!team) {
-      const prevTeam = await prisma.team.findFirstOrThrow({ where: { id } });
+      const prevTeam = await teamRepository.findById({ id });
+
+      if (!prevTeam) throw new Error("Prev team not found");
 
       metadata = teamMetadataStrictSchema.safeParse(prevTeam.metadata);
       if (!metadata.success) {
         throw new HttpError({ statusCode: 400, message: "Invalid team metadata" });
       }
 
       const { requestedSlug, ...newMetadata } = metadata.data || {};
-      team = await prisma.team.update({
-        where: { id },
+      team = await teamRepository.updateById({
+        id,
         data: {
           metadata: {
             ...newMetadata,
@@ -71,8 +74,14 @@ async function getHandler(req: NextRequest, { params }: { params: Promise<Params
       const slug = prevTeam.slug || requestedSlug;
       if (slug) {
         try {
-          team = await prisma.team.update({ where: { id }, data: { slug } });
+          team = await teamRepository.updateById({ id, data: { slug } });
         } catch (error) {
+          await teamRepository.updateById({
+            id,
+            data: {
+              plan: team.isOrganization ? Plans.ORGANIZATIONS : Plans.TEAMS,
+            },
+          });
           const { message, statusCode } = getRequestedSlugError(error, slug);
           return NextResponse.json({ message }, { status: statusCode });
         }
@@ -86,6 +95,13 @@ async function getHandler(req: NextRequest, { params }: { params: Promise<Params
       }
     }
 
+    await teamRepository.updateById({
+      id,
+      data: {
+        plan: team.isOrganization ? Plans.ORGANIZATIONS : Plans.TEAMS,
+      },
+    });
+
     const session = await getServerSession({ req: buildLegacyRequest(await headers(), await cookies()) });
 
     if (!session) {

apps/web/app/api/teams/create/route.ts

@@ -7,7 +7,7 @@ import { z } from "zod";
 import stripe from "@calcom/features/ee/payments/server/stripe";
 import { HttpError } from "@calcom/lib/http-error";
 import prisma from "@calcom/prisma";
-import { MembershipRole } from "@calcom/prisma/enums";
+import { MembershipRole, Plans } from "@calcom/prisma/enums";
 
 const querySchema = z.object({
   session_id: z.string().min(1),
@@ -69,6 +69,7 @@ async function getHandler(req: NextRequest) {
     data: {
       name: checkoutSessionMetadata.teamName,
       slug: checkoutSessionMetadata.teamSlug,
+      plan: Plans.TEAMS,
       members: {
         create: {
           userId: checkoutSessionMetadata.userId as number,

packages/features/ee/billing/constants.ts

@@ -7,3 +7,15 @@ export const CHECKOUT_SESSION_TYPES = {
 } as const;
 
 export type CheckoutSessionType = (typeof CHECKOUT_SESSION_TYPES)[keyof typeof CHECKOUT_SESSION_TYPES];
+
+export enum BillingPlans {
+  INDIVIDUALS = "INDIVIDUALS",
+  TEAMS = "TEAMS",
+  ORGANIZATIONS = "ORGANIZATIONS",
+  ENTERPRISE = "ENTERPRISE",
+  PLATFORM_STARTER = "PLATFORM_STARTER",
+  PLATFORM_ESSENTIALS = "PLATFORM_ESSENTIALS",
+  PLATFORM_SCALE = "PLATFORM_SCALE",
+  PLATFORM_ENTERPRISE = "PLATFORM_ENTERPRISE",
+  UNKNOWN = "Unknown",
+}

packages/features/ee/billing/domain/billing-plans.ts

@@ -0,0 +1,51 @@
+import { BillingPlans } from "@calcom/ee/billing/constants";
+import type { Plans } from "@calcom/prisma/enums";
+
+export class BillingPlanService {
+  async getUserPlanByMemberships(
+    memberships: {
+      team: {
+        plan: Plans | null;
+        isOrganization: boolean;
+        isPlatform: boolean;
+        parent: {
+          isOrganization: boolean;
+          isPlatform: boolean;
+          plan: Plans | null;
+        } | null;
+        platformBilling: {
+          plan: string;
+        } | null;
+      };
+      user: {
+        isPlatformManaged: boolean;
+      };
+    }[]
+  ) {
+    if (memberships.length === 0) return BillingPlans.INDIVIDUALS;
+
+    for (const { team, user } of memberships) {
+      if (team.isPlatform || user.isPlatformManaged) {
+        if (!team.platformBilling) continue;
+
+        switch (team.platformBilling.plan) {
+          case "FREE":
+          case "STARTER":
+            return BillingPlans.PLATFORM_STARTER;
+          case "ESSENTIALS":
+            return BillingPlans.PLATFORM_ESSENTIALS;
+          case "SCALE":
+            return BillingPlans.PLATFORM_SCALE;
+          case "ENTERPRISE":
+            return BillingPlans.PLATFORM_ENTERPRISE;
+          default:
+            return team.platformBilling.plan;
+        }
+      } else {
+        if (team.parent?.plan) return team.parent.plan;
+        if (team.plan) return team.plan;
+      }
+    }
+    return BillingPlans.UNKNOWN;
+  }
+}

packages/features/ee/billing/teams/internal-team-billing.test.ts

@@ -58,6 +58,7 @@ describe("InternalTeamBilling", () => {
         where: { id: 1 },
         data: {
           metadata: {},
+          plan: null,
         },
       });
     });

packages/features/ee/billing/teams/internal-team-billing.ts

@@ -7,7 +7,6 @@ import { getMetadataHelpers } from "@calcom/lib/getMetadataHelpers";
 import logger from "@calcom/lib/logger";
 import { Redirect } from "@calcom/lib/redirect";
 import { safeStringify } from "@calcom/lib/safeStringify";
-import { OrganizationOnboardingRepository } from "@calcom/lib/server/repository/organizationOnboarding";
 import { prisma } from "@calcom/prisma";
 import type { Prisma } from "@calcom/prisma/client";
 import { teamMetadataStrictSchema } from "@calcom/prisma/zod-utils";
@@ -113,7 +112,7 @@ export class InternalTeamBilling implements TeamBilling {
         subscriptionId: undefined,
         subscriptionItemId: undefined,
       });
-      await prisma.team.update({ where: { id: this.team.id }, data: { metadata } });
+      await prisma.team.update({ where: { id: this.team.id }, data: { metadata, plan: null } });
       log.info(`Downgraded team ${this.team.id}`);
     } catch (error) {
       this.logErrorFromUnknown(error);
@@ -125,9 +124,6 @@ export class InternalTeamBilling implements TeamBilling {
       const { id: teamId, metadata, isOrganization } = this.team;
 
       const { url } = await this.checkIfTeamPaymentRequired();
-      const organizationOnboarding = await OrganizationOnboardingRepository.findByOrganizationId(
-        this.team.id
-      );
       log.debug("updateQuantity", safeStringify({ url, team: this.team }));
 
       /**

packages/features/ee/organizations/lib/server/createOrganizationFromOnboarding.test.ts

@@ -10,7 +10,7 @@ import { LicenseKeySingleton } from "@calcom/ee/common/server/LicenseKeyService"
 import * as constants from "@calcom/lib/constants";
 import { createDomain } from "@calcom/lib/domainManager/organization";
 import type { OrganizationOnboarding } from "@calcom/prisma/client";
-import { MembershipRole } from "@calcom/prisma/enums";
+import { MembershipRole, Plans } from "@calcom/prisma/enums";
 import { createTeamsHandler } from "@calcom/trpc/server/routers/viewer/organizations/createTeams.handler";
 import { inviteMembersWithNoInviterPermissionCheck } from "@calcom/trpc/server/routers/viewer/teams/inviteMember/inviteMember.handler";
 
@@ -66,8 +66,8 @@ const mockOrganizationOnboarding = {
   createdById: 1,
   invitedMembers: [{ email: "[email protected]" }, { email: "[email protected]" }],
   teams: [
-    { id: 1, name: "Team To Move", isBeingMigrated: true, slug: "new-team-slug" },
-    { id: 2, name: "New Team", isBeingMigrated: false, slug: null },
+    { id: 1, name: "Team To Move", isBeingMigrated: true, slug: "new-team-slug", plan: Plans.TEAMS },
+    { id: 2, name: "New Team", isBeingMigrated: false, slug: null, plan: Plans.TEAMS },
   ],
   logo: null,
   bio: null,
@@ -81,6 +81,7 @@ async function createTestUser(data: {
   email: string;
   name?: string;
   username?: string;
+  //eslint-disable-next-line @typescript-eslint/no-explicit-any
   metadata?: any;
   onboardingCompleted?: boolean;
   emailVerified?: Date | null;
@@ -101,6 +102,7 @@ async function createTestOrganization(data: {
   name: string;
   slug: string;
   isOrganization?: boolean;
+  //eslint-disable-next-line @typescript-eslint/no-explicit-any
   metadata?: any;
 }) {
   return prismock.team.create({
@@ -244,6 +246,19 @@ describe("createOrganizationFromOnboarding", () => {
       expect(organization.name).toBe(organizationOnboarding.name);
       expect(organization.slug).toBe(organizationOnboarding.slug);
 
+      //parent team plan and sub teams plan should be updated to organizations
+      expect(organization.plan).toBe(Plans.ORGANIZATIONS);
+
+      const teams = await prismock.team.findMany({
+        where: {
+          id: {
+            in: organizationOnboarding.teams?.map((t) => t.id),
+          },
+        },
+      });
+
+      expect(teams.every((t) => t.plan === Plans.ORGANIZATIONS)).toBe(true);
+
       // Verify owner is the existing user
       expect(owner.id).toBe(existingUser.id);
       expect(owner.email).toBe(existingUser.email);

packages/features/ee/support/lib/intercom/useIntercom.ts

@@ -40,7 +40,7 @@ export const useIntercom = () => {
       },
     },
   });
-  const { hasPaidPlan } = useHasPaidPlan();
+  const { hasPaidPlan, plan } = useHasPaidPlan();
   const { hasTeamPlan } = useHasTeamPlan();
 
   const boot = async () => {
@@ -83,6 +83,7 @@ export const useIntercom = () => {
         sum_of_event_types: statsData?.sumOfEventTypes,
         sum_of_team_event_types: statsData?.sumOfTeamEventTypes,
         is_premium: data?.isPremium,
+        Plan: plan,
       },
     });
   };
@@ -127,6 +128,7 @@ export const useIntercom = () => {
         sum_of_event_types: statsData?.sumOfEventTypes,
         sum_of_team_event_types: statsData?.sumOfTeamEventTypes,
         is_premium: data?.isPremium,
+        Plan: plan,
       },
     });
     hookData.show();

packages/lib/hooks/useHasPaidPlan.ts

@@ -6,7 +6,7 @@ import hasKeyInMetadata from "../hasKeyInMetadata";
 export function useHasPaidPlan() {
   if (IS_SELF_HOSTED) return { isPending: false, hasPaidPlan: true };
 
-  const { data: hasTeamPlan, isPending: isPendingTeamQuery } = trpc.viewer.teams.hasTeamPlan.useQuery();
+  const { data, isPending: isPendingTeamQuery } = trpc.viewer.teams.hasTeamPlan.useQuery();
 
   const { data: user, isPending: isPendingUserQuery } = trpc.viewer.me.get.useQuery();
 
@@ -15,9 +15,9 @@ export function useHasPaidPlan() {
   const isCurrentUsernamePremium =
     user && hasKeyInMetadata(user, "isPremium") ? !!user.metadata.isPremium : false;
 
-  const hasPaidPlan = hasTeamPlan?.hasTeamPlan || isCurrentUsernamePremium;
+  const hasPaidPlan = data?.hasTeamPlan || isCurrentUsernamePremium;
 
-  return { isPending, hasPaidPlan };
+  return { isPending, hasPaidPlan, plan: data?.plan };
 }
 
 export function useTeamInvites() {

packages/lib/server/repository/membership.ts

@@ -1,7 +1,6 @@
-
 import { availabilityUserSelect, prisma, type PrismaTransaction } from "@calcom/prisma";
-import { MembershipRole } from "@calcom/prisma/enums";
 import type { Prisma, Membership, PrismaClient } from "@calcom/prisma/client";
+import { MembershipRole } from "@calcom/prisma/enums";
 import { credentialForCalendarServiceSelect } from "@calcom/prisma/selects/credential";
 
 import logger from "../../logger";
@@ -315,6 +314,40 @@ export class MembershipRepository {
     });
   }
 
+  static async findAllMembershipsByUserIdForBilling({ userId }: { userId: number }) {
+    return await prisma.membership.findMany({
+      where: { userId },
+      select: {
+        accepted: true,
+        user: {
+          select: {
+            isPlatformManaged: true,
+          },
+        },
+        team: {
+          select: {
+            slug: true,
+            plan: true,
+            isOrganization: true,
+            isPlatform: true,
+            platformBilling: {
+              select: {
+                plan: true,
+              },
+            },
+            parent: {
+              select: {
+                plan: true,
+                isOrganization: true,
+                isPlatform: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
   static async findByTeamIdForAvailability({ teamId }: { teamId: number }) {
     const memberships = await prisma.membership.findMany({
       where: { teamId },