Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

14.7 KB
Raw Blame
import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'

import api from 'lib/api'
import { OrganizationMembershipLevel } from 'lib/constants'
import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { permanentlyMount } from 'lib/utils/kea-logic-builders'
import { membershipLevelToName } from 'lib/utils/permissioning'
import { organizationLogic } from 'scenes/organizationLogic'
import { userLogic } from 'scenes/userLogic'

import { OrganizationMemberScopedApiKeysResponse, OrganizationMemberType, UserType } from '~/types'

const PAGINATION_LIMIT = 200

function meAsMember(user: UserType): OrganizationMemberType {
    return {
        id: '',
        user: {
            uuid: user.uuid,
            distinct_id: user.distinct_id,
            first_name: user.first_name,
            last_name: user.last_name,
            email: user.email,
            id: user.id,
            is_email_verified: user.is_email_verified,
            role_at_organization: user.role_at_organization,
        },
        level: user.organization?.membership_level ?? OrganizationMembershipLevel.Member,
        last_login: null,
        joined_at: '',
        updated_at: '',
        is_2fa_enabled: user.is_2fa_enabled ?? false,
        has_social_auth: user.has_social_auth,
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface membersLogicValues {
    user: UserType | null // userLogic
    filteredMembers: OrganizationMemberType[]
    me: OrganizationMemberType | null
    meFirstMembers: OrganizationMemberType[]
    memberCount: number
    members: OrganizationMemberType[] | null
    membersLoading: boolean
    otherMembers: OrganizationMemberType[]
    scopedApiKeys: OrganizationMemberScopedApiKeysResponse | null
    scopedApiKeysLoading: boolean
    search: string
    searchedMembers: OrganizationMemberType[] | null
    searchedMembersLoading: boolean
    selectableMembers: (membersToExclude?: (number | string)[], by?: 'id' | 'uuid') => OrganizationMemberType[]
    sortedMembers: OrganizationMemberType[] | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface membersLogicActions {
    changeMemberAccessLevel: (
        member: OrganizationMemberType,
        level: OrganizationMembershipLevel
    ) => {
        level: OrganizationMembershipLevel
        member: OrganizationMemberType
    }
    changeMemberAccessLevelFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    changeMemberAccessLevelSuccess: (
        members: OrganizationMemberType[] | null,
        payload?: {
            level: OrganizationMembershipLevel
            member: OrganizationMemberType
        }
    ) => {
        members: OrganizationMemberType[] | null
        payload?: {
            level: OrganizationMembershipLevel
            member: OrganizationMemberType
        }
    }
    ensureAllMembersLoaded: () => {
        value: true
    }
    loadAllMembers: () => {
        value: true
    }
    loadAllMembersFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadAllMembersSuccess: (
        members: OrganizationMemberType[],
        payload?: {
            value: true
        }
    ) => {
        members: OrganizationMemberType[]
        payload?: {
            value: true
        }
    }
    loadMemberScopedApiKeys: (member: OrganizationMemberType) => {
        member: OrganizationMemberType
    }
    loadMemberScopedApiKeysFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadMemberScopedApiKeysSuccess: (
        scopedApiKeys: OrganizationMemberScopedApiKeysResponse | null,
        payload?: {
            member: OrganizationMemberType
        }
    ) => {
        scopedApiKeys: OrganizationMemberScopedApiKeysResponse | null
        payload?: {
            member: OrganizationMemberType
        }
    }
    loadMemberUpdates: () => {
        value: true
    }
    loadMemberUpdatesFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadMemberUpdatesSuccess: (
        members: OrganizationMemberType[] | null,
        payload?: {
            value: true
        }
    ) => {
        members: OrganizationMemberType[] | null
        payload?: {
            value: true
        }
    }
    loadSearchedMembers: () => {
        value: true
    }
    loadSearchedMembersFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadSearchedMembersSuccess: (
        searchedMembers: OrganizationMemberType[] | null,
        payload?: {
            value: true
        }
    ) => {
        searchedMembers: OrganizationMemberType[] | null
        payload?: {
            value: true
        }
    }
    postRemoveMember: (userUuid: string) => {
        userUuid: string
    }
    setSearch: (search: any) => {
        search: any
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface membersLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        sortedMembers: (members: OrganizationMemberType[] | null) => OrganizationMemberType[] | null
        meFirstMembers: (
            sortedMembers: OrganizationMemberType[] | null,
            user: UserType | null
        ) => OrganizationMemberType[]
        me: (user: UserType | null) => OrganizationMemberType | null
        otherMembers: (filteredMembers: OrganizationMemberType[], user: UserType | null) => OrganizationMemberType[]
        selectableMembers: (
            me: OrganizationMemberType | null,
            otherMembers: OrganizationMemberType[],
            search: string
        ) => (membersToExclude?: (number | string)[], by?: 'id' | 'uuid') => OrganizationMemberType[]
        filteredMembers: (
            meFirstMembers: OrganizationMemberType[],
            searchedMembers: OrganizationMemberType[] | null,
            search: string
        ) => OrganizationMemberType[]
        memberCount: (user: UserType | null, sortedMembers: OrganizationMemberType[] | null) => number
    }
}

export type membersLogicType = MakeLogicType<
    membersLogicValues,
    membersLogicActions,
    Record<string, any>,
    membersLogicMeta
>

export const membersLogic = kea<membersLogicType>([
    path(['scenes', 'organization', 'membersLogic']),
    connect(() => ({
        values: [userLogic, ['user']],
    })),
    actions({
        ensureAllMembersLoaded: true,
        loadAllMembers: true,
        loadMemberUpdates: true,
        loadSearchedMembers: true,
        loadMemberScopedApiKeys: (member: OrganizationMemberType) => ({ member }),
        setSearch: (search) => ({ search }),
        changeMemberAccessLevel: (member: OrganizationMemberType, level: OrganizationMembershipLevel) => ({
            member,
            level,
        }),
        postRemoveMember: (userUuid: string) => ({ userUuid }),
    }),
    loaders(({ values }) => ({
        members: {
            __default: null as OrganizationMemberType[] | null,
            loadAllMembers: async () => {
                return await api.organizationMembers.listAll({
                    limit: PAGINATION_LIMIT,
                })
            },
            loadMemberUpdates: async () => {
                const newestMemberUpdate = values.members?.sort((a, b) => (a.updated_at > b.updated_at ? -1 : 1))?.[0]

                if (!newestMemberUpdate || !values.members) {
                    return null
                }

                const membersResponse = await api.organizationMembers.list({
                    updated_after: newestMemberUpdate.updated_at,
                })

                const members = [...values.members]

                membersResponse.results.forEach((member) => {
                    // Update or add the members
                    const existingIndex = members.findIndex((m) => m.user.uuid === member.user.uuid)
                    if (existingIndex !== -1) {
                        members[existingIndex] = member
                    } else {
                        members.push(member)
                    }
                })

                return members
            },
            changeMemberAccessLevel: async ({ member, level }) => {
                const updatedMember = await api.organizationMembers.update(member.user.uuid, { level })
                lemonToast.success(
                    <>
                        Made <b>{member.user.first_name}</b> organization {membershipLevelToName.get(level)}
                    </>
                )
                // reload organization to account for no longer being organization owner
                if (level === OrganizationMembershipLevel.Owner) {
                    organizationLogic.actions.loadCurrentOrganization()
                }

                if (!values.members) {
                    return null
                }
                const updatedMembers = [...values.members]

                const existingIndex = values.members.findIndex((m) => m.user.uuid === member.user.uuid)
                if (existingIndex !== -1) {
                    updatedMembers[existingIndex] = updatedMember
                }
                return updatedMembers
            },
        },
        scopedApiKeys: {
            __default: null as OrganizationMemberScopedApiKeysResponse | null,
            loadMemberScopedApiKeys: async ({ member }: { member: OrganizationMemberType }) => {
                try {
                    const res = await api.organizationMembers.scopedApiKeys.list(member.user.uuid)
                    return res
                } catch {
                    return null
                }
            },
        },
        // Server-side search results — separate from the canonical `members` store so
        // other consumers (rolesLogic, hedgehogModeLogic, etc.) keep seeing the full org
        // when the user has a search term active in the org-settings members page.
        searchedMembers: {
            __default: null as OrganizationMemberType[] | null,
            loadSearchedMembers: async () => {
                const search = values.search?.trim()
                if (!search) {
                    return null
                }
                return await api.organizationMembers.listAll({
                    limit: PAGINATION_LIMIT,
                    search,
                })
            },
        },
    })),
    reducers({
        members: [
            null as OrganizationMemberType[] | null,
            {
                postRemoveMember: (state, { userUuid }) =>
                    state?.filter((member) => member.user.uuid !== userUuid) ?? null,
            },
        ],
        search: ['', { setSearch: (_, { search }) => search }],
    }),
    selectors({
        sortedMembers: [
            (s) => [s.members],
            (members: OrganizationMemberType[] | null): OrganizationMemberType[] | null => {
                if (!members) {
                    return null
                }
                return members.sort((a, b) => (a.user.first_name > b.user.first_name ? 1 : -1))
            },
        ],
        meFirstMembers: [
            (s) => [s.sortedMembers, s.user],
            (members: OrganizationMemberType[] | null, user: UserType | null): OrganizationMemberType[] => {
                const me = user && members?.find((member) => member.user.uuid === user.uuid)
                const result: OrganizationMemberType[] = me ? [me] : []
                for (const member of members ?? []) {
                    if (!user || member.user.uuid !== user.uuid) {
                        result.push(member)
                    }
                }
                return result
            },
        ],
        me: [
            (s) => [s.user],
            (user: UserType | null): OrganizationMemberType | null => (user ? meAsMember(user) : null),
        ],
        otherMembers: [
            (s) => [s.filteredMembers, s.user],
            (filteredMembers: OrganizationMemberType[], user: UserType | null): OrganizationMemberType[] =>
                user ? filteredMembers.filter((member) => member.user.uuid !== user.uuid) : filteredMembers,
        ],
        selectableMembers: [
            (s) => [s.me, s.otherMembers, s.search],
            (me: OrganizationMemberType | null, otherMembers: OrganizationMemberType[], search: string) =>
                (membersToExclude: (string | number)[] = [], by: 'id' | 'uuid' = 'id'): OrganizationMemberType[] => {
                    const members = me && !search.trim() ? [me, ...otherMembers] : otherMembers
                    return members.filter((member) => !membersToExclude.includes(member.user[by]))
                },
        ],
        filteredMembers: [
            (s) => [s.meFirstMembers, s.searchedMembers, s.search],
            (
                members: OrganizationMemberType[],
                searched: OrganizationMemberType[] | null,
                search: string
            ): OrganizationMemberType[] => {
                // When a search term is set, return the (server-filtered) searchedMembers
                // — this avoids polluting the canonical `members` store with a filtered
                // subset, so other consumers (rolesLogic, hedgehogModeLogic) keep seeing
                // the full org. me-first is dropped during search because the user is
                // looking for someone else, not themselves.
                if (search?.trim()) {
                    return searched ?? []
                }
                return members ?? []
            },
        ],
        memberCount: [
            (s) => [s.user, s.sortedMembers],
            (user: UserType | null, members: OrganizationMemberType[] | null): number => {
                // Typically we can rely on the app context but just in case we use the loaded members if present
                const count = user?.organization?.member_count
                return Math.max(count ?? 0, members?.length ?? 0)
            },
        ],
    }),

    listeners(({ values, actions }) => ({
        postRemoveMember: async ({ userUuid }) => {
            if (userUuid === userLogic.values.user?.uuid) {
                location.reload()
            }
        },

        ensureAllMembersLoaded: async () => {
            if (values.membersLoading) {
                return
            }
            if (!values.members) {
                actions.loadAllMembers()
            } else {
                actions.loadMemberUpdates()
            }
        },

        setSearch: async (_, breakpoint) => {
            await breakpoint(250)
            actions.loadSearchedMembers()
        },
    })),

    permanentlyMount(),
])