chore: remove feature flag owner

codegen.json

@@ -13,6 +13,7 @@
         "mappers": {
           "AddFeatureFlagSuccess": "./types/AddFeatureFlagSuccess#AddFeatureFlagSuccessSource",
           "ApplyFeatureFlagSuccess": "./types/ApplyFeatureFlagSuccess#ApplyFeatureFlagSuccessSource",
+          "RemoveFeatureFlagOwnerSuccess": "./types/RemoveFeatureFlagOwnerSuccess#RemoveFeatureFlagOwnerSuccessSource",
           "DeleteFeatureFlagSuccess": "./types/DeleteFeatureFlagSuccess#DeleteFeatureFlagSuccessSource",
           "UpdateFeatureFlagSuccess": "./types/UpdateFeatureFlagSuccess#UpdateFeatureFlagSuccessSource",
           "ChangeEmailDomainSuccess": "./types/ChangeEmailDomainSuccess#ChangeEmailDomainSuccessSource",

packages/server/graphql/private/mutations/removeFeatureFlagOwner.ts

@@ -0,0 +1,107 @@
+import getKysely from '../../../postgres/getKysely'
+import getUsersByDomain from '../../../postgres/queries/getUsersByDomain'
+import {getUsersByEmails} from '../../../postgres/queries/getUsersByEmails'
+import {getUserId} from '../../../utils/authorization'
+import standardError from '../../../utils/standardError'
+import {MutationResolvers} from '../resolverTypes'
+
+const removeFeatureFlagOwner: MutationResolvers['removeFeatureFlagOwner'] = async (
+  _source,
+  {flagName, subjects},
+  {authToken}
+) => {
+  const pg = getKysely()
+
+  const viewerId = getUserId(authToken)
+
+  const subjectKeys = Object.keys(subjects)
+
+  if (subjectKeys.length === 0) {
+    return standardError(new Error('At least one subject type must be provided'), {
+      userId: viewerId
+    })
+  }
+
+  const featureFlag = await pg
+    .selectFrom('FeatureFlag')
+    .select(['id', 'scope'])
+    .where('featureName', '=', flagName)
+    .executeTakeFirst()
+
+  if (!featureFlag) {
+    return standardError(new Error('Feature flag not found'), {userId: viewerId})
+  }
+
+  const {id: featureFlagId, scope} = featureFlag
+
+  const userIds: string[] = []
+  const teamIds: string[] = []
+  const orgIds: string[] = []
+
+  if (scope === 'User') {
+    if (subjects.emails) {
+      const users = await getUsersByEmails(subjects.emails)
+      userIds.push(...users.map((user) => user.id))
+    }
+
+    if (subjects.domains) {
+      for (const domain of subjects.domains) {
+        const domainUsers = await getUsersByDomain(domain)
+        userIds.push(...domainUsers.map((user) => user.id))
+      }
+    }
+
+    if (subjects.userIds) {
+      userIds.push(...subjects.userIds)
+    }
+  } else if (scope === 'Team') {
+    if (subjects.teamIds) {
+      teamIds.push(...subjects.teamIds)
+    }
+  } else if (scope === 'Organization') {
+    if (subjects.orgIds) {
+      orgIds.push(...subjects.orgIds)
+    }
+  }
+
+  let deletedCount = 0
+
+  if (scope === 'User' && userIds.length > 0) {
+    const result = await pg
+      .deleteFrom('FeatureFlagOwner')
+      .where('featureFlagId', '=', featureFlagId)
+      .where('userId', 'in', userIds)
+      .executeTakeFirst()
+    deletedCount = Number(result?.numDeletedRows ?? 0)
+  } else if (scope === 'Team' && teamIds.length > 0) {
+    const result = await pg
+      .deleteFrom('FeatureFlagOwner')
+      .where('featureFlagId', '=', featureFlagId)
+      .where('teamId', 'in', teamIds)
+      .executeTakeFirst()
+    deletedCount = Number(result?.numDeletedRows ?? 0)
+  } else if (scope === 'Organization' && orgIds.length > 0) {
+    const result = await pg
+      .deleteFrom('FeatureFlagOwner')
+      .where('featureFlagId', '=', featureFlagId)
+      .where('orgId', 'in', orgIds)
+      .executeTakeFirst()
+    deletedCount = Number(result?.numDeletedRows ?? 0)
+  }
+
+  if (deletedCount === 0) {
+    return standardError(
+      new Error('No feature flag owners were removed. Check the scope and subjects provided.')
+    )
+  }
+
+  return {
+    featureFlagId,
+    removedCount: deletedCount,
+    userIds: scope === 'User' ? userIds : [],
+    teamIds: scope === 'Team' ? teamIds : [],
+    orgIds: scope === 'Organization' ? orgIds : []
+  }
+}
+
+export default removeFeatureFlagOwner

packages/server/graphql/private/typeDefs/Mutation.graphql

@@ -38,6 +38,20 @@ type Mutation {
     subjects: SubjectsInput!
   ): ApplyFeatureFlagPayload!
 
+  """
+  Remove a feature flag from specified subjects (users, teams, or organizations)
+  """
+  removeFeatureFlagOwner(
+    """
+    The name of the feature flag to remove
+    """
+    flagName: String!
+    """
+    The subjects from which the feature flag will be removed
+    """
+    subjects: SubjectsInput!
+  ): RemoveFeatureFlagOwnerPayload!
+
   """
   Delete an existing feature flag
   """

packages/server/graphql/private/typeDefs/RemoveFeatureFlagOwnerSuccess.graphql

@@ -0,0 +1,25 @@
+"""
+Successful result of removing a feature flag owner
+"""
+type RemoveFeatureFlagOwnerSuccess {
+  """
+  The feature flag that was removed
+  """
+  featureFlag: FeatureFlag!
+  """
+  The feature flag was removed from the following users
+  """
+  users: [User!]
+  """
+  The feature flag was removed from the following teams
+  """
+  teams: [Team!]
+  """
+  The feature flag was removed from the following organizations
+  """
+  organizations: [Organization!]
+  """
+  The number of subjects the feature flag was removed from
+  """
+  removedCount: Int!
+}

packages/server/graphql/private/typeDefs/RemoveFeatureFlagPayload.graphql

@@ -0,0 +1,4 @@
+"""
+Return value for removeFeatureFlagOwner, which could be an error or success
+"""
+union RemoveFeatureFlagOwnerPayload = ErrorPayload | RemoveFeatureFlagOwnerSuccess

packages/server/graphql/private/types/RemoveFeatureFlagOwnerSuccess.ts

@@ -0,0 +1,31 @@
+import isValid from '../../isValid'
+import {RemoveFeatureFlagOwnerSuccessResolvers} from '../resolverTypes'
+
+export type RemoveFeatureFlagOwnerSuccessSource = {
+  featureFlagId: string
+  userIds: string[] | null
+  teamIds: string[] | null
+  orgIds: string[] | null
+  removedCount: number
+}
+
+const RemoveFeatureFlagOwnerSuccess: RemoveFeatureFlagOwnerSuccessResolvers = {
+  featureFlag: async ({featureFlagId}, _args, {dataLoader}) => {
+    return dataLoader.get('featureFlags').loadNonNull(featureFlagId)
+  },
+  users: async ({userIds}, _args, {dataLoader}) => {
+    if (!userIds) return null
+    return (await dataLoader.get('users').loadMany(userIds)).filter(isValid)
+  },
+  teams: async ({teamIds}, _args, {dataLoader}) => {
+    if (!teamIds) return null
+    return (await dataLoader.get('teams').loadMany(teamIds)).filter(isValid)
+  },
+  organizations: async ({orgIds}, _args, {dataLoader}) => {
+    if (!orgIds) return null
+    return (await dataLoader.get('organizations').loadMany(orgIds)).filter(isValid)
+  },
+  removedCount: ({removedCount}) => removedCount
+}
+
+export default RemoveFeatureFlagOwnerSuccess