feat: add organisations (#1820)

packages/lib/server-only/profile/get-public-profile-by-url.ts

@@ -1,15 +1,8 @@
 import type { Template, TemplateDirectLink } from '@prisma/client';
-import {
-  SubscriptionStatus,
-  type TeamProfile,
-  TemplateType,
-  type UserProfile,
-} from '@prisma/client';
+import { type TeamProfile, TemplateType } from '@prisma/client';
 
-import { getCommunityPlanPriceIds } from '@documenso/ee/server-only/stripe/get-community-plan-prices';
 import { prisma } from '@documenso/prisma';
 
-import { IS_BILLING_ENABLED } from '../../constants/app';
 import { AppError, AppErrorCode } from '../../errors/app-error';
 
 export type GetPublicProfileByUrlOptions = {
@@ -23,7 +16,7 @@ type PublicDirectLinkTemplate = Template & {
   };
 };
 
-type BaseResponse = {
+type GetPublicProfileByUrlResponse = {
   url: string;
   name: string;
   avatarImageId?: string | null;
@@ -32,155 +25,56 @@ type BaseResponse = {
     since: Date;
   };
   templates: PublicDirectLinkTemplate[];
+  profile: TeamProfile;
 };
 
-type GetPublicProfileByUrlResponse = BaseResponse &
-  (
-    | {
-        type: 'User';
-        profile: UserProfile;
-      }
-    | {
-        type: 'Team';
-        profile: TeamProfile;
-      }
-  );
-
 /**
  * Get the user or team public profile by URL.
  */
 export const getPublicProfileByUrl = async ({
   profileUrl,
 }: GetPublicProfileByUrlOptions): Promise<GetPublicProfileByUrlResponse> => {
-  const [user, team] = await Promise.all([
-    prisma.user.findFirst({
-      where: {
-        url: profileUrl,
-        profile: {
-          enabled: true,
+  const team = await prisma.team.findFirst({
+    where: {
+      url: profileUrl,
+      profile: {
+        enabled: true,
+      },
+    },
+    include: {
+      profile: true,
+      templates: {
+        where: {
+          directLink: {
+            enabled: true,
+          },
+          type: TemplateType.PUBLIC,
+        },
+        include: {
+          directLink: true,
         },
       },
-      include: {
-        profile: true,
-        templates: {
-          where: {
-            directLink: {
-              enabled: true,
-            },
-            type: TemplateType.PUBLIC,
-          },
-          include: {
-            directLink: true,
-          },
-        },
-        // Subscriptions and teamMembers are used to calculate the badges.
-        subscriptions: {
-          where: {
-            status: SubscriptionStatus.ACTIVE,
-          },
-        },
-        teamMembers: {
-          select: {
-            createdAt: true,
-          },
-          orderBy: {
-            createdAt: 'asc',
-          },
-        },
-      },
-    }),
-    prisma.team.findFirst({
-      where: {
-        url: profileUrl,
-        profile: {
-          enabled: true,
-        },
-      },
-      include: {
-        profile: true,
-        templates: {
-          where: {
-            directLink: {
-              enabled: true,
-            },
-            type: TemplateType.PUBLIC,
-          },
-          include: {
-            directLink: true,
-          },
-        },
-      },
-    }),
-  ]);
+    },
+  });
 
-  // Log as critical error.
-  if (user?.profile && team?.profile) {
-    console.error('Profile URL is ambiguous', { profileUrl, userId: user.id, teamId: team.id });
-    throw new AppError(AppErrorCode.INVALID_REQUEST, {
-      message: 'Profile URL is ambiguous',
+  if (!team?.profile?.enabled) {
+    throw new AppError(AppErrorCode.NOT_FOUND, {
+      message: 'Profile not found',
     });
   }
 
-  if (user?.profile?.enabled) {
-    let badge: BaseResponse['badge'] = undefined;
-
-    if (user.teamMembers[0]) {
-      badge = {
-        type: 'Premium',
-        since: user.teamMembers[0]['createdAt'],
-      };
-    }
-
-    if (IS_BILLING_ENABLED()) {
-      const earlyAdopterPriceIds = await getCommunityPlanPriceIds();
-
-      const activeEarlyAdopterSub = user.subscriptions.find(
-        (subscription) =>
-          subscription.status === SubscriptionStatus.ACTIVE &&
-          earlyAdopterPriceIds.includes(subscription.priceId),
-      );
-
-      if (activeEarlyAdopterSub) {
-        badge = {
-          type: 'EarlySupporter',
-          since: activeEarlyAdopterSub.createdAt,
-        };
-      }
-    }
-
-    return {
-      type: 'User',
-      badge,
-      profile: user.profile,
-      url: profileUrl,
-      avatarImageId: user.avatarImageId,
-      name: user.name || '',
-      templates: user.templates.filter(
-        (template): template is PublicDirectLinkTemplate =>
-          template.directLink?.enabled === true && template.type === TemplateType.PUBLIC,
-      ),
-    };
-  }
-
-  if (team?.profile?.enabled) {
-    return {
-      type: 'Team',
-      badge: {
-        type: 'Premium',
-        since: team.createdAt,
-      },
-      profile: team.profile,
-      url: profileUrl,
-      avatarImageId: team.avatarImageId,
-      name: team.name || '',
-      templates: team.templates.filter(
-        (template): template is PublicDirectLinkTemplate =>
-          template.directLink?.enabled === true && template.type === TemplateType.PUBLIC,
-      ),
-    };
-  }
-
-  throw new AppError(AppErrorCode.NOT_FOUND, {
-    message: 'Profile not found',
-  });
+  return {
+    badge: {
+      type: 'Premium',
+      since: team.createdAt,
+    },
+    profile: team.profile,
+    url: profileUrl,
+    avatarImageId: team.avatarImageId,
+    name: team.name || '',
+    templates: team.templates.filter(
+      (template): template is PublicDirectLinkTemplate =>
+        template.directLink?.enabled === true && template.type === TemplateType.PUBLIC,
+    ),
+  };
 };