: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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()
}
}),
])