feat: add organisations (#1820)

packages/lib/server-only/team/get-team.ts

@@ -1,72 +1,22 @@
-import type { Prisma } from '@prisma/client';
-import type { z } from 'zod';
-
 import { prisma } from '@documenso/prisma';
-import { TeamEmailSchema } from '@documenso/prisma/generated/zod/modelSchema/TeamEmailSchema';
-import { TeamGlobalSettingsSchema } from '@documenso/prisma/generated/zod/modelSchema/TeamGlobalSettingsSchema';
-import { TeamMemberSchema } from '@documenso/prisma/generated/zod/modelSchema/TeamMemberSchema';
-import { TeamSchema } from '@documenso/prisma/generated/zod/modelSchema/TeamSchema';
 
 import { AppError, AppErrorCode } from '../../errors/app-error';
+import {
+  buildTeamWhereQuery,
+  extractDerivedTeamSettings,
+  getHighestTeamRoleInGroup,
+} from '../../utils/teams';
 
 export type GetTeamByIdOptions = {
-  userId?: number;
+  userId: number;
   teamId: number;
 };
 
-export const ZGetTeamByIdResponseSchema = TeamSchema.extend({
-  teamEmail: TeamEmailSchema.nullable(),
-  teamGlobalSettings: TeamGlobalSettingsSchema.nullable(),
-  currentTeamMember: TeamMemberSchema.pick({
-    role: true,
-  }).nullable(),
-});
-
-export type TGetTeamByIdResponse = z.infer<typeof ZGetTeamByIdResponseSchema>;
-
-/**
- * Get a team given a teamId.
- *
- * Provide an optional userId to check that the user is a member of the team.
- */
-export const getTeamById = async ({
-  userId,
-  teamId,
-}: GetTeamByIdOptions): Promise<TGetTeamByIdResponse> => {
-  const whereFilter: Prisma.TeamWhereUniqueInput = {
-    id: teamId,
-  };
-
-  if (userId !== undefined) {
-    whereFilter['members'] = {
-      some: {
-        userId,
-      },
-    };
-  }
-
-  const result = await prisma.team.findUniqueOrThrow({
-    where: whereFilter,
-    include: {
-      teamEmail: true,
-      teamGlobalSettings: true,
-      members: {
-        where: {
-          userId,
-        },
-        select: {
-          role: true,
-        },
-      },
-    },
+export const getTeamById = async ({ userId, teamId }: GetTeamByIdOptions) => {
+  return await getTeam({
+    teamReference: teamId,
+    userId,
   });
-
-  const { members, ...team } = result;
-
-  return {
-    ...team,
-    currentTeamMember: userId !== undefined ? members[0] : null,
-  };
 };
 
 export type GetTeamByUrlOptions = {
@@ -80,57 +30,65 @@ export type TGetTeamByUrlResponse = Awaited<ReturnType<typeof getTeamByUrl>>;
  * Get a team given a team URL.
  */
 export const getTeamByUrl = async ({ userId, teamUrl }: GetTeamByUrlOptions) => {
-  const whereFilter: Prisma.TeamWhereUniqueInput = {
-    url: teamUrl,
-  };
+  return await getTeam({
+    teamReference: teamUrl,
+    userId,
+  });
+};
 
-  if (userId !== undefined) {
-    whereFilter['members'] = {
-      some: {
-        userId,
-      },
-    };
-  }
-
-  const result = await prisma.team.findFirst({
-    where: whereFilter,
+/**
+ * Get a team by its ID or URL.
+ */
+export const getTeam = async ({
+  teamReference,
+  userId,
+}: {
+  teamReference: number | string;
+  userId: number;
+}) => {
+  const team = await prisma.team.findFirst({
+    where: {
+      ...buildTeamWhereQuery({ teamId: undefined, userId }),
+      id: typeof teamReference === 'number' ? teamReference : undefined,
+      url: typeof teamReference === 'string' ? teamReference : undefined,
+    },
     include: {
       teamEmail: true,
-      emailVerification: {
-        select: {
-          expiresAt: true,
-          name: true,
-          email: true,
-        },
-      },
-      transferVerification: {
-        select: {
-          expiresAt: true,
-          name: true,
-          email: true,
-        },
-      },
-      subscription: true,
-      teamGlobalSettings: true,
-      members: {
+      teamGroups: {
         where: {
-          userId,
+          organisationGroup: {
+            organisationGroupMembers: {
+              some: {
+                organisationMember: {
+                  userId,
+                },
+              },
+            },
+          },
         },
-        select: {
-          role: true,
+      },
+      teamGlobalSettings: true,
+      organisation: {
+        include: {
+          organisationGlobalSettings: true,
         },
       },
     },
   });
 
-  if (!result) {
-    throw new AppError(AppErrorCode.NOT_FOUND);
+  if (!team) {
+    throw new AppError(AppErrorCode.NOT_FOUND, {
+      message: 'Team not found',
+    });
   }
 
-  const { members, ...team } = result;
+  const organisationSettings = team.organisation.organisationGlobalSettings;
+  const teamSettings = team.teamGlobalSettings;
 
   return {
     ...team,
-    currentTeamMember: members[0],
+    currentTeamRole: getHighestTeamRoleInGroup(team.teamGroups),
+    teamSettings,
+    derivedSettings: extractDerivedTeamSettings(organisationSettings, teamSettings),
   };
 };