feat: implement deleteUsers mutation

codegen.json

@@ -82,6 +82,7 @@
           "CreateStripeSubscriptionSuccess": "./types/CreateStripeSubscriptionSuccess#CreateStripeSubscriptionSuccessSource",
           "CreateTaskPayload": "./types/CreateTaskPayload#CreateTaskPayloadSource",
           "DeleteCommentSuccess": "./types/DeleteCommentSuccess#DeleteCommentSuccessSource",
+          "DeleteUsersSuccess": "./types/DeleteUsersSuccess#DeleteUsersSuccessSource",
           "Discussion": "../../postgres/types/index#Discussion",
           "DomainJoinRequest": "../../database/types/DomainJoinRequest#default as DomainJoinRequestDB",
           "EndTeamPromptSuccess": "./types/EndTeamPromptSuccess#EndTeamPromptSuccessSource",

packages/client/mutations/DeleteUsersMutation.ts

@@ -0,0 +1,36 @@
+import graphql from 'babel-plugin-relay/macro'
+import {commitMutation} from 'react-relay'
+import {DeleteUsersMutation as TDeleteUsersMutation} from '../__generated__/DeleteUsersMutation.graphql'
+import {StandardMutation} from '../types/relayMutations'
+
+graphql`
+  fragment DeleteUsersMutation_users on DeleteUsersSuccess {
+    deletedUsers {
+      id
+      email
+      isRemoved
+    }
+  }
+`
+
+const mutation = graphql`
+  mutation DeleteUsersMutation($emails: [Email!]!) {
+    deleteUsers(emails: $emails) {
+      ... on ErrorPayload {
+        error {
+          message
+        }
+      }
+      ...DeleteUsersMutation_users @relay(mask: false)
+    }
+  }
+`
+
+const DeleteUsersMutation: StandardMutation<TDeleteUsersMutation> = (atmosphere, variables) => {
+  return commitMutation<TDeleteUsersMutation>(atmosphere, {
+    mutation,
+    variables
+  })
+}
+
+export default DeleteUsersMutation

packages/server/__tests__/deleteUsers.test.ts

@@ -0,0 +1,63 @@
+import {sendIntranet, signUp} from './common'
+
+test('Delete users by email', async () => {
+  const user1 = await signUp()
+  const user2 = await signUp()
+  const emails = [user1.email, user2.email]
+  const userIds = [user1.userId, user2.userId]
+
+  const deleteUsers = await sendIntranet({
+    query: `
+      mutation DeleteUsers($emails: [Email!]!) {
+        deleteUsers(emails: $emails) {
+          ... on ErrorPayload {
+            error {
+              message
+            }
+          }
+          ... on DeleteUsersSuccess {
+            deletedUsers {
+              id
+              email
+              isRemoved
+            }
+          }
+        }
+      }
+    `,
+    variables: {
+      emails
+    }
+  })
+
+  expect(deleteUsers.data.deleteUsers.deletedUsers).toHaveLength(2)
+
+  // Verify both users were deleted
+  for (const userId of userIds) {
+    const user = await sendIntranet({
+      query: `
+        query User($userId: ID!) {
+          user(userId: $userId) {
+            id
+            isRemoved
+            email
+          }
+        }
+      `,
+      variables: {
+        userId
+      },
+      isPrivate: true
+    })
+
+    expect(user).toMatchObject({
+      data: {
+        user: {
+          id: userId,
+          isRemoved: true,
+          email: expect.not.stringMatching(emails[userIds.indexOf(userId)] || '')
+        }
+      }
+    })
+  }
+}, 40000)

packages/server/graphql/mutations/deleteUser.ts

@@ -9,7 +9,7 @@ import DeleteUserPayload from '../types/DeleteUserPayload'
 import sendAccountRemovedEvent from './helpers/sendAccountRemovedEvent'
 import softDeleteUser from './helpers/softDeleteUser'
 
-const markUserSoftDeleted = async (
+export const markUserSoftDeleted = async (
   userIdToDelete: string,
   deletedUserEmail: string,
   validReason: string

packages/server/graphql/public/mutations/deleteUsers.ts

@@ -0,0 +1,100 @@
+import {USER_BATCH_DELETE_LIMIT} from '../../../postgres/constants'
+import {getUsersByEmails} from '../../../postgres/queries/getUsersByEmails'
+import {getUserById} from '../../../postgres/queries/getUsersByIds'
+import {
+  getUserId,
+  isSuperUser,
+  isUserBillingLeader,
+  isUserOrgAdmin
+} from '../../../utils/authorization'
+import getDomainFromEmail from '../../../utils/getDomainFromEmail'
+import {GQLContext} from '../../graphql'
+import {markUserSoftDeleted} from '../../mutations/deleteUser'
+import softDeleteUser from '../../mutations/helpers/softDeleteUser'
+import {MutationResolvers} from '../resolverTypes'
+
+const deleteUsers: MutationResolvers['deleteUsers'] = async (
+  _source,
+  {emails}: {emails: string[]},
+  {authToken, dataLoader}: GQLContext
+) => {
+  if (emails.length === 0) {
+    return {error: {message: 'No emails provided'}}
+  }
+
+  if (emails.length > USER_BATCH_DELETE_LIMIT) {
+    return {error: {message: `Cannot delete more than ${USER_BATCH_DELETE_LIMIT} users at once`}}
+  }
+
+  const su = isSuperUser(authToken)
+  const viewerId = getUserId(authToken)
+  const viewer = await getUserById(viewerId)
+  if (!viewer) return {error: {message: 'Invalid viewer'}}
+
+  const usersToDelete = await getUsersByEmails(emails)
+  if (usersToDelete.length === 0) {
+    return {error: {message: 'No valid users found to delete'}}
+  } else if (usersToDelete.length !== emails.length) {
+    const missingEmails = emails.filter(
+      (email) => !usersToDelete.some((user) => user.email === email)
+    )
+    return {error: {message: `Some users were not found: ${missingEmails.join(', ')}`}}
+  }
+
+  // First check all permissions before making any changes
+  const viewerOrgUsers = await dataLoader.get('organizationUsersByUserId').load(viewerId)
+  const permissionChecks = await Promise.all(
+    usersToDelete.map(async (userToDelete) => {
+      // Super users can delete anyone
+      if (su) return {userId: userToDelete.id, hasPermission: true}
+
+      const orgUsers = await dataLoader.get('organizationUsersByUserId').load(userToDelete.id)
+
+      // Check permissions for each org the user belongs to
+      const hasOrgPermission = await Promise.all(
+        orgUsers.map(async ({orgId}) => {
+          const viewerOrgUser = viewerOrgUsers.find((vu) => vu.orgId === orgId)
+          if (!viewerOrgUser) return false
+
+          const [isOrgAdmin, isBillingLeader] = await Promise.all([
+            isUserOrgAdmin(viewerId, orgId, dataLoader),
+            isUserBillingLeader(viewerId, orgId, dataLoader)
+          ])
+
+          if (!(isOrgAdmin || isBillingLeader)) return false
+
+          const organization = await dataLoader.get('organizations').loadNonNull(orgId)
+          return organization.activeDomain === getDomainFromEmail(userToDelete.email)
+        })
+      )
+
+      return {
+        userId: userToDelete.id,
+        hasPermission: hasOrgPermission.some(Boolean)
+      }
+    })
+  )
+
+  // Check if we have permission to delete ALL users
+  const unauthorizedUsers = usersToDelete.filter((_, idx) => !permissionChecks[idx]!.hasPermission)
+  if (unauthorizedUsers.length > 0) {
+    return {
+      error: {
+        message: `You don't have permission to remove the following users: ${unauthorizedUsers.map((user) => user.email).join(', ')}`
+      }
+    }
+  }
+
+  // If we have permission for all users, perform the deletions
+  const deletedUserIds = await Promise.all(
+    permissionChecks.map(async ({userId}) => {
+      const deletedUserEmail = await softDeleteUser(userId, dataLoader)
+      await markUserSoftDeleted(userId, deletedUserEmail, 'Mass user deletion')
+      return userId
+    })
+  )
+
+  return {deletedUserIds}
+}
+
+export default deleteUsers

packages/server/graphql/public/typeDefs/DeleteUsersPayload.graphql

@@ -0,0 +1 @@
+union DeleteUsersPayload = ErrorPayload | DeleteUsersSuccess

packages/server/graphql/public/typeDefs/DeleteUsersSuccess.graphql

@@ -0,0 +1,11 @@
+type DeleteUsersSuccess {
+  """
+  the ids of the deleted users
+  """
+  deletedUserIds: [ID!]
+
+  """
+  the deleted users
+  """
+  deletedUsers: [User!]
+}

packages/server/graphql/public/typeDefs/Mutation.graphql

@@ -226,6 +226,16 @@ type Mutation {
     reason: String
   ): DeleteUserPayload!
 
+  """
+  Delete a list of users, removing them from all teams and orgs
+  """
+  deleteUsers(
+    """
+    a list of user emails
+    """
+    emails: [Email!]!
+  ): DeleteUsersPayload!
+
   """
   Deny a user from joining via push invitation
   """

packages/server/graphql/public/types/DeleteUsersSuccess.ts

@@ -0,0 +1,15 @@
+import isValid from '../../isValid'
+import {DeleteUsersSuccessResolvers} from '../resolverTypes'
+
+export type DeleteUsersSuccessSource = {
+  deletedUserIds: string[]
+}
+
+const DeleteUsersSuccess: DeleteUsersSuccessResolvers = {
+  deletedUsers: async ({deletedUserIds}, _args, {dataLoader}) => {
+    const users = (await dataLoader.get('users').loadMany(deletedUserIds)).filter(isValid)
+    return users
+  }
+}
+
+export default DeleteUsersSuccess

packages/server/postgres/constants.ts

@@ -2,5 +2,6 @@ export const USER_EMAIL_LIMIT = 500
 export const USER_PREFERRED_NAME_LIMIT = 100
 export const USER_OVERLIMIT_COPY_LIMIT = 500
 export const USER_REASON_REMOVED_LIMIT = 2000
+export const USER_BATCH_DELETE_LIMIT = 100
 
 export const TEAM_NAME_LIMIT = 100