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.

27.0 KB
Raw Blame
import {
    MakeLogicType,
    actions,
    afterMount,
    connect,
    kea,
    key,
    listeners,
    path,
    props,
    propsChanged,
    reducers,
    selectors,
} from 'kea'
import { forms } from 'kea-forms'
import type { DeepPartialMap, ValidationErrorType } from 'kea-forms'
import type { DeepPartial, FieldName } from 'kea-forms'
import { loaders } from 'kea-loaders'
import { router } from 'kea-router'

import { FEATURE_FLAGS } from 'lib/constants'
import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
import type { FeatureFlagsSet } from 'lib/logic/featureFlagLogic'
import { organizationLogic } from 'scenes/organizationLogic'
import { Scene } from 'scenes/sceneTypes'
import { urls } from 'scenes/urls'

import * as api from '~/generated/core/api'
import {
    ConfigScopeEnumApi,
    DomainScopeEnumApi,
    IdentityProviderConfigApi,
    OrganizationDomainApi,
} from '~/generated/core/api.schemas'
import type { Breadcrumb } from '~/types'

import { identityProviderConfigsLogic } from './identityProviderConfigsLogic'
import {
    IDENTITY_PROVIDER_FEATURES,
    getIdentityProviderConfigsForScope,
    hasSamlDomainScopeConflict,
} from './identityProviderConfigUtils'

export interface IdentityProviderConfigLogicProps {
    configScope: ConfigScopeEnumApi | null
    configId: string
}

export interface IdentityProviderConfigForm {
    name: string
    domain_scope: DomainScopeEnumApi
    organization_domain_ids: string[]
    saml_entity_id: string
    saml_acs_url: string
    saml_x509_cert: string
    oidc_issuer_url: string
    oidc_client_id: string
    oidc_client_secret: string
    oidc_client_secret_cleared: boolean
    scim_enabled: boolean
    id_jag_issuer_url: string
    id_jag_jwks_url: string
    id_jag_allowed_clients: string[]
}

type IdentityProviderConfigWritePayload = Pick<IdentityProviderConfigApi, 'domain_scope' | 'organization_domain_ids'> &
    Partial<
        Pick<
            IdentityProviderConfigApi,
            | 'config_scope'
            | 'saml_entity_id'
            | 'saml_acs_url'
            | 'saml_x509_cert'
            | 'oidc_issuer_url'
            | 'oidc_client_id'
            | 'oidc_client_secret'
            | 'scim_enabled'
            | 'id_jag_issuer_url'
            | 'id_jag_jwks_url'
            | 'id_jag_allowed_clients'
        >
    >

const NEW_CONFIG_ID = 'new'
const ORGANIZATION_DOMAINS_PAGE_SIZE = 100

const emptyIdentityProviderConfigForm = (): IdentityProviderConfigForm => ({
    name: '',
    domain_scope: DomainScopeEnumApi.All,
    organization_domain_ids: [],
    saml_entity_id: '',
    saml_acs_url: '',
    saml_x509_cert: '',
    oidc_issuer_url: '',
    oidc_client_id: '',
    oidc_client_secret: '',
    oidc_client_secret_cleared: false,
    scim_enabled: false,
    id_jag_issuer_url: '',
    id_jag_jwks_url: '',
    id_jag_allowed_clients: [],
})

const formValuesFromConfig = (config: IdentityProviderConfigApi | null): IdentityProviderConfigForm => ({
    name: config?.name ?? '',
    domain_scope:
        !config || config.domain_scope === DomainScopeEnumApi.All
            ? DomainScopeEnumApi.All
            : DomainScopeEnumApi.Selected,
    organization_domain_ids: config?.organization_domain_ids ?? [],
    saml_entity_id: config?.saml_entity_id ?? '',
    saml_acs_url: config?.saml_acs_url ?? '',
    saml_x509_cert: config?.saml_x509_cert ?? '',
    oidc_issuer_url: config?.oidc_issuer_url ?? '',
    oidc_client_id: config?.oidc_client_id ?? '',
    oidc_client_secret: '',
    oidc_client_secret_cleared: false,
    scim_enabled: config?.scim_enabled ?? false,
    id_jag_issuer_url: config?.id_jag_issuer_url ?? '',
    id_jag_jwks_url: config?.id_jag_jwks_url ?? '',
    id_jag_allowed_clients: config?.id_jag_allowed_clients ?? [],
})

const payloadFromForm = (
    configScope: ConfigScopeEnumApi,
    formValues: IdentityProviderConfigForm
): IdentityProviderConfigWritePayload => {
    const commonPayload = {
        name: formValues.name.trim(),
        domain_scope: formValues.domain_scope,
        organization_domain_ids:
            formValues.domain_scope === DomainScopeEnumApi.All ? [] : formValues.organization_domain_ids,
    }

    if (configScope === ConfigScopeEnumApi.Saml) {
        return {
            ...commonPayload,
            saml_entity_id: formValues.saml_entity_id.trim() || null,
            saml_acs_url: formValues.saml_acs_url.trim() || null,
            saml_x509_cert: formValues.saml_x509_cert.trim() || null,
        }
    }

    if (configScope === ConfigScopeEnumApi.Scim) {
        return { ...commonPayload, scim_enabled: formValues.scim_enabled }
    }

    if (configScope === ConfigScopeEnumApi.Oidc) {
        return {
            ...commonPayload,
            oidc_issuer_url: formValues.oidc_issuer_url.trim(),
            oidc_client_id: formValues.oidc_client_id.trim(),
            // A typed secret must win over the cleared flag. The flag stays set once the admin opens the
            // input, so testing it first would send an empty secret and delete the credential instead of
            // rotating it.
            ...(formValues.oidc_client_secret
                ? { oidc_client_secret: formValues.oidc_client_secret }
                : formValues.oidc_client_secret_cleared
                  ? { oidc_client_secret: '' }
                  : {}),
        }
    }

    return {
        ...commonPayload,
        id_jag_issuer_url: formValues.id_jag_issuer_url.trim() || null,
        id_jag_jwks_url: formValues.id_jag_jwks_url.trim() || null,
        id_jag_allowed_clients: formValues.id_jag_allowed_clients,
    }
}

const isSecureUrl = (value: string): boolean => {
    try {
        return new URL(value).protocol === 'https:'
    } catch {
        return false
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface identityProviderConfigLogicValues {
    featureFlags: FeatureFlagsSet // featureFlagLogic
    receivedFeatureFlags: boolean // featureFlagLogic
    identityProviderConfigs: IdentityProviderConfigApi[] | null // identityProviderConfigsLogic
    currentOrganizationId: string // organizationLogic
    breadcrumbs: Breadcrumb[]
    configId: string
    configScope: ConfigScopeEnumApi | null
    deleteConfirmation: string
    hasSamlDomainScopeConflict: boolean
    identityProviderConfig: IdentityProviderConfigApi | null
    identityProviderConfigDeleting: boolean
    identityProviderConfigDeletingLoading: boolean
    identityProviderConfigForm: IdentityProviderConfigForm
    identityProviderConfigFormAllErrors: Record<string, any>
    identityProviderConfigFormChanged: boolean
    identityProviderConfigFormErrors: DeepPartialMap<IdentityProviderConfigForm, ValidationErrorType>
    identityProviderConfigFormHasErrors: boolean
    identityProviderConfigFormManualErrors: Record<string, any>
    identityProviderConfigFormTouched: boolean
    identityProviderConfigFormTouches: Record<string, boolean>
    identityProviderConfigFormValidationErrors: DeepPartialMap<IdentityProviderConfigForm, ValidationErrorType>
    identityProviderConfigLoadFailed: boolean
    identityProviderConfigLoaded: boolean
    identityProviderConfigLoading: boolean
    isConfigScopeValid: boolean
    isDeleteModalOpen: boolean
    isIdentityProviderConfigFormSubmitting: boolean
    isIdentityProviderConfigFormValid: boolean
    isRedesignEnabled: boolean
    organizationDomains: OrganizationDomainApi[] | null
    organizationDomainsLoadFailed: boolean
    organizationDomainsLoading: boolean
    regeneratedScimToken: string | null
    regeneratedScimTokenLoading: boolean
    revealedScimToken: string | null
    showIdentityProviderConfigFormErrors: boolean
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface identityProviderConfigLogicActions {
    setFeatureFlags: (
        flags: string[],
        variants: Record<string, boolean | string>
    ) => {
        flags: string[]
        variants: Record<string, boolean | string>
    } // featureFlagLogic
    loadIdentityProviderConfigs: () => any // identityProviderConfigsLogic
    loadIdentityProviderConfigsSuccess: (
        identityProviderConfigs: IdentityProviderConfigApi[],
        payload?: any
    ) => {
        identityProviderConfigs: IdentityProviderConfigApi[]
        payload?: any
    } // identityProviderConfigsLogic
    closeDeleteModal: () => {}
    deleteIdentityProviderConfig: () => any
    deleteIdentityProviderConfigFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    deleteIdentityProviderConfigSuccess: (
        identityProviderConfigDeleting: boolean,
        payload?: any
    ) => {
        identityProviderConfigDeleting: boolean
        payload?: any
    }
    loadIdentityProviderConfig: () => any
    loadIdentityProviderConfigFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadIdentityProviderConfigSuccess: (
        identityProviderConfig: IdentityProviderConfigApi | null,
        payload?: any
    ) => {
        identityProviderConfig: IdentityProviderConfigApi | null
        payload?: any
    }
    loadOrganizationDomains: () => any
    loadOrganizationDomainsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadOrganizationDomainsSuccess: (
        organizationDomains: OrganizationDomainApi[],
        payload?: any
    ) => {
        organizationDomains: OrganizationDomainApi[]
        payload?: any
    }
    openDeleteModal: () => {}
    regenerateScimToken: () => any
    regenerateScimTokenFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    regenerateScimTokenSuccess: (
        regeneratedScimToken: string | null,
        payload?: any
    ) => {
        regeneratedScimToken: string | null
        payload?: any
    }
    resetIdentityProviderConfigForm: (values?: IdentityProviderConfigForm) => {
        values?: IdentityProviderConfigForm
    }
    setDeleteConfirmation: (confirmation: string) => {
        confirmation: string
    }
    setIdentityProviderConfigFormManualErrors: (errors: Record<string, any>) => {
        errors: Record<string, any>
    }
    setIdentityProviderConfigFormValue: (
        key: FieldName,
        value: any
    ) => {
        name: FieldName
        value: any
    }
    setIdentityProviderConfigFormValues: (values: DeepPartial<IdentityProviderConfigForm>) => {
        values: DeepPartial<IdentityProviderConfigForm>
    }
    setRevealedScimToken: (token: string | null) => {
        token: string | null
    }
    submitIdentityProviderConfigForm: () => {
        value: boolean
    }
    submitIdentityProviderConfigFormFailure: (
        error: Error,
        errors: Record<string, any>
    ) => {
        error: Error
        errors: Record<string, any>
    }
    submitIdentityProviderConfigFormRequest: (identityProviderConfigForm: IdentityProviderConfigForm) => {
        identityProviderConfigForm: IdentityProviderConfigForm
    }
    submitIdentityProviderConfigFormSuccess: (identityProviderConfigForm: IdentityProviderConfigForm) => {
        identityProviderConfigForm: IdentityProviderConfigForm
    }
    touchIdentityProviderConfigFormField: (key: string) => {
        key: string
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface identityProviderConfigLogicMeta {
    key: ConfigScopeEnumApi | 'invalid'
    __keaTypeGenInternalSelectorTypes: {
        configId: (configId: string) => string
        configScope: (configScope: ConfigScopeEnumApi | null) => ConfigScopeEnumApi | null
        isRedesignEnabled: (featureFlags: FeatureFlagsSet, arg: any) => boolean
        isConfigScopeValid: (identityProviderConfig: IdentityProviderConfigApi | null, arg: any) => boolean
        hasSamlDomainScopeConflict: (
            identityProviderConfig: IdentityProviderConfigApi | null,
            identityProviderConfigForm: IdentityProviderConfigForm,
            identityProviderConfigs: IdentityProviderConfigApi[] | null,
            organizationDomains: OrganizationDomainApi[] | null,
            arg: any
        ) => boolean
        breadcrumbs: (configScope: ConfigScopeEnumApi | null) => Breadcrumb[]
    }
}

export type identityProviderConfigLogicType = MakeLogicType<
    identityProviderConfigLogicValues,
    identityProviderConfigLogicActions,
    IdentityProviderConfigLogicProps,
    identityProviderConfigLogicMeta
>

export const identityProviderConfigLogic = kea<identityProviderConfigLogicType>([
    props({ configScope: null, configId: NEW_CONFIG_ID } as IdentityProviderConfigLogicProps),
    key((props) => props.configScope ?? 'invalid'),
    path((logicKey) => [
        'scenes',
        'settings',
        'organization',
        'identityProviderConfig',
        'identityProviderConfigLogic',
        logicKey,
    ]),
    connect(() => ({
        values: [
            organizationLogic,
            ['currentOrganizationId'],
            identityProviderConfigsLogic,
            ['identityProviderConfigs'],
            featureFlagLogic,
            ['featureFlags', 'receivedFeatureFlags'],
        ],
        actions: [
            featureFlagLogic,
            ['setFeatureFlags'],
            identityProviderConfigsLogic,
            ['loadIdentityProviderConfigsSuccess', 'loadIdentityProviderConfigs'],
        ],
    })),
    actions({
        setRevealedScimToken: (token: string | null) => ({ token }),
        openDeleteModal: () => ({}),
        closeDeleteModal: () => ({}),
        setDeleteConfirmation: (confirmation: string) => ({ confirmation }),
    }),
    forms(({ actions, props, values }) => ({
        identityProviderConfigForm: {
            defaults: emptyIdentityProviderConfigForm(),
            errors: (formValues) => ({
                organization_domain_ids:
                    formValues.domain_scope === DomainScopeEnumApi.Selected &&
                    formValues.organization_domain_ids.length === 0
                        ? ['Select at least one domain']
                        : undefined,
                saml_acs_url:
                    props.configScope === ConfigScopeEnumApi.Saml &&
                    formValues.saml_acs_url &&
                    !isSecureUrl(formValues.saml_acs_url)
                        ? 'Enter a valid URL that starts with https://'
                        : undefined,
                id_jag_issuer_url:
                    props.configScope === ConfigScopeEnumApi.Xaa &&
                    formValues.id_jag_issuer_url &&
                    !isSecureUrl(formValues.id_jag_issuer_url)
                        ? 'Enter a valid URL that starts with https://'
                        : undefined,
                oidc_issuer_url:
                    props.configScope === ConfigScopeEnumApi.Oidc &&
                    formValues.oidc_issuer_url &&
                    !isSecureUrl(formValues.oidc_issuer_url)
                        ? 'Enter a valid URL that starts with https://'
                        : undefined,
                id_jag_jwks_url:
                    props.configScope === ConfigScopeEnumApi.Xaa &&
                    formValues.id_jag_jwks_url &&
                    !isSecureUrl(formValues.id_jag_jwks_url)
                        ? 'Enter a valid URL that starts with https://'
                        : undefined,
            }),
            submit: async (formValues) => {
                if (!props.configScope) {
                    return
                }

                const payload = payloadFromForm(props.configScope, formValues)
                const config =
                    props.configId === NEW_CONFIG_ID
                        ? await api.identityProviderConfigsCreate(values.currentOrganizationId, {
                              ...payload,
                              config_scope: props.configScope,
                          })
                        : await api.identityProviderConfigsPartialUpdate(
                              values.currentOrganizationId,
                              props.configId,
                              payload
                          )

                actions.loadIdentityProviderConfigSuccess(config)
                actions.setRevealedScimToken(config.scim_bearer_token)
            },
        },
    })),
    loaders(({ props, values }) => ({
        identityProviderConfig: [
            null as IdentityProviderConfigApi | null,
            {
                loadIdentityProviderConfig: async () =>
                    props.configId === NEW_CONFIG_ID
                        ? null
                        : await api.identityProviderConfigsRetrieve(values.currentOrganizationId, props.configId),
            },
        ],
        identityProviderConfigDeleting: [
            false,
            {
                deleteIdentityProviderConfig: async () => {
                    if (!values.identityProviderConfig || values.identityProviderConfig.config_scope == null) {
                        throw new Error('Only feature-specific identity provider configurations can be deleted.')
                    }
                    await api.identityProviderConfigsDestroy(
                        values.currentOrganizationId,
                        values.identityProviderConfig.id
                    )
                    return true
                },
            },
        ],
        organizationDomains: [
            null as OrganizationDomainApi[] | null,
            {
                loadOrganizationDomains: async () => {
                    const organizationDomains: OrganizationDomainApi[] = []
                    let offset = 0
                    let next: string | null | undefined

                    do {
                        const page = await api.domainsList(values.currentOrganizationId, {
                            limit: ORGANIZATION_DOMAINS_PAGE_SIZE,
                            offset,
                        })
                        organizationDomains.push(...page.results)
                        offset += ORGANIZATION_DOMAINS_PAGE_SIZE
                        next = page.next
                    } while (next)

                    return organizationDomains
                },
            },
        ],
        regeneratedScimToken: [
            null as string | null,
            {
                regenerateScimToken: async () => {
                    if (!values.identityProviderConfig) {
                        return null
                    }
                    const response = await api.identityProviderConfigsScimTokenCreate(
                        values.currentOrganizationId,
                        values.identityProviderConfig.id
                    )
                    return response.scim_bearer_token
                },
            },
        ],
    })),
    reducers({
        identityProviderConfigLoaded: [
            false,
            {
                loadIdentityProviderConfig: () => false,
                loadIdentityProviderConfigSuccess: () => true,
                loadIdentityProviderConfigFailure: () => true,
            },
        ],
        identityProviderConfigLoadFailed: [
            false,
            {
                loadIdentityProviderConfig: () => false,
                loadIdentityProviderConfigFailure: () => true,
            },
        ],
        organizationDomainsLoadFailed: [
            false,
            {
                loadOrganizationDomains: () => false,
                loadOrganizationDomainsFailure: () => true,
            },
        ],
        revealedScimToken: [
            null as string | null,
            {
                loadIdentityProviderConfig: () => null,
                setRevealedScimToken: (_, { token }) => token,
            },
        ],
        isDeleteModalOpen: [
            false,
            {
                openDeleteModal: () => true,
                closeDeleteModal: () => false,
            },
        ],
        deleteConfirmation: [
            '',
            {
                // A stale confirmation must not survive a reopen, or a typed confirmation
                // from last time would let a single click delete the config.
                openDeleteModal: () => '',
                setDeleteConfirmation: (_, { confirmation }) => confirmation,
            },
        ],
    }),
    selectors({
        configId: [(_, props) => [props.configId], (configId: string): string => configId],
        configScope: [
            (_, props) => [props.configScope],
            (configScope: ConfigScopeEnumApi | null): ConfigScopeEnumApi | null => configScope,
        ],
        isRedesignEnabled: [
            (selectors) => [selectors.featureFlags, (_, props) => props.configScope],
            (featureFlags: FeatureFlagsSet, configScope: ConfigScopeEnumApi | null): boolean =>
                !!featureFlags[FEATURE_FLAGS.SSO_SETTINGS_REDESIGN] &&
                (configScope !== ConfigScopeEnumApi.Xaa || !!featureFlags[FEATURE_FLAGS.XAA_AUTHENTICATION]),
        ],
        isConfigScopeValid: [
            (selectors) => [selectors.identityProviderConfig, (_, props) => props.configScope],
            (config: IdentityProviderConfigApi | null, configScope: ConfigScopeEnumApi | null): boolean =>
                !!configScope &&
                (!config ||
                    config.config_scope === configScope ||
                    (configScope !== ConfigScopeEnumApi.Oidc && !config.config_scope)),
        ],
        hasSamlDomainScopeConflict: [
            (selectors) => [
                selectors.identityProviderConfig,
                selectors.identityProviderConfigForm,
                selectors.identityProviderConfigs,
                selectors.organizationDomains,
                (_, props) => props.configScope,
            ],
            (
                identityProviderConfig: IdentityProviderConfigApi | null,
                form: IdentityProviderConfigForm,
                configs: IdentityProviderConfigApi[] | null,
                domains: OrganizationDomainApi[] | null,
                configScope: ConfigScopeEnumApi | null
            ): boolean =>
                configScope === ConfigScopeEnumApi.Saml &&
                hasSamlDomainScopeConflict(
                    configs,
                    identityProviderConfig?.id ?? null,
                    form.domain_scope,
                    form.organization_domain_ids,
                    domains?.filter((domain) => domain.is_verified).map((domain) => domain.id) ?? []
                ),
        ],
        breadcrumbs: [
            (_, props) => [props.configScope],
            (configScope: ConfigScopeEnumApi | null): Breadcrumb[] => [
                {
                    key: Scene.Settings,
                    name: 'Settings - Authentication domains & SSO',
                    path: urls.settings('organization-authentication'),
                    iconType: 'settings',
                },
                {
                    key: Scene.IdentityProviderConfig,
                    name: configScope ? `Configure ${IDENTITY_PROVIDER_FEATURES[configScope].name}` : 'Configure SSO',
                },
            ],
        ],
    }),
    listeners(({ actions, props, values }) => ({
        setFeatureFlags: () => {
            if (!values.isRedesignEnabled) {
                router.actions.replace(urls.settings('organization-authentication'))
            }
        },
        loadIdentityProviderConfigSuccess: ({ identityProviderConfig }) => {
            const form = formValuesFromConfig(identityProviderConfig)
            if (!identityProviderConfig && props.configId === NEW_CONFIG_ID && props.configScope) {
                const hasExistingConfig = values.identityProviderConfigs
                    ? getIdentityProviderConfigsForScope(values.identityProviderConfigs, props.configScope).length > 0
                    : false
                form.name = hasExistingConfig
                    ? ''
                    : `Default ${IDENTITY_PROVIDER_FEATURES[props.configScope].name} configuration`
            }
            actions.resetIdentityProviderConfigForm(form)
        },
        loadIdentityProviderConfigsSuccess: ({ identityProviderConfigs }) => {
            if (props.configId === NEW_CONFIG_ID && props.configScope) {
                // The list can finish after the form is interactive. Reconcile the guessed
                // default name only while the user hasn't edited the form.
                if (values.identityProviderConfigFormChanged) {
                    return
                }
                const hasExistingConfig =
                    getIdentityProviderConfigsForScope(identityProviderConfigs, props.configScope).length > 0
                actions.resetIdentityProviderConfigForm({
                    ...values.identityProviderConfigForm,
                    name: hasExistingConfig
                        ? ''
                        : `Default ${IDENTITY_PROVIDER_FEATURES[props.configScope].name} configuration`,
                })
            }
        },
        submitIdentityProviderConfigFormSuccess: () => {
            actions.loadIdentityProviderConfigs()
            const config = values.identityProviderConfig
            if (!config || !props.configScope) {
                return
            }

            actions.resetIdentityProviderConfigForm(formValuesFromConfig(config))
            if (props.configId === NEW_CONFIG_ID && config.id) {
                // Adopt the saved config's URL so another save updates it instead of creating a duplicate.
                router.actions.replace(urls.identityProviderConfig(props.configScope, config.id))
            }
            lemonToast.success(`${IDENTITY_PROVIDER_FEATURES[props.configScope].name} configuration saved.`)
        },
        submitIdentityProviderConfigFormFailure: () => {
            lemonToast.error('Could not save the identity provider configuration. Check the form and try again.')
        },
        deleteIdentityProviderConfigSuccess: () => {
            actions.loadIdentityProviderConfigs()
            router.actions.replace(urls.settings('organization-authentication'))
            lemonToast.success('Identity provider configuration deleted.')
        },
        deleteIdentityProviderConfigFailure: () => {
            lemonToast.error('Could not delete the identity provider configuration. Try again.')
        },
        regenerateScimTokenSuccess: ({ regeneratedScimToken }) => {
            actions.setRevealedScimToken(regeneratedScimToken)
            lemonToast.success('SCIM token regenerated.')
        },
    })),
    afterMount(({ actions, values }) => {
        if (values.receivedFeatureFlags && !values.isRedesignEnabled) {
            router.actions.replace(urls.settings('organization-authentication'))
            return
        }
        actions.loadIdentityProviderConfig()
        actions.loadOrganizationDomains()
    }),
    propsChanged(({ actions, props, values }, oldProps) => {
        if (
            oldProps.configId !== props.configId &&
            !(oldProps.configId === NEW_CONFIG_ID && values.identityProviderConfig?.id === props.configId)
        ) {
            actions.loadIdentityProviderConfig()
        }
    }),
])