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.

6.7 KB
Raw Blame
import { MakeLogicType, actions, afterMount, kea, key, listeners, path, props, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { router } from 'kea-router'

import api, { ApiError } from 'lib/api'
import { lemonToast } from 'lib/lemon-ui/LemonToast'

import { DomainConnectProviderName } from '~/queries/schema/schema-general'

import type { EmailDomainConnectCheckApi } from 'products/integrations/frontend/generated/api.schemas'

export interface DomainConnectProvider {
    endpoint: string
    name: DomainConnectProviderName
}

export type DomainConnectInfo = EmailDomainConnectCheckApi

export interface DomainConnectLogicProps {
    /** Unique key to prevent state sharing between instances (not `key` because React strips it) */
    logicKey: string
    /** The domain to check Domain Connect support for */
    domain: string | null
    /** Which resource type this Domain Connect flow is for */
    context: 'email' | 'proxy'
    /** Required when context is 'email' */
    integrationId?: number
    /** Required when context is 'proxy' */
    proxyRecordId?: string
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface domainConnectLogicValues {
    autoDetected: boolean
    availableProviders: DomainConnectProvider[]
    domainConnectInfo: any
    domainConnectInfoLoading: boolean
    hasAnyOption: boolean
    providerName: DomainConnectProviderName | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface domainConnectLogicActions {
    checkDomain: () => {
        value: true
    }
    checkDomainFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    checkDomainSuccess: (
        domainConnectInfo: EmailDomainConnectCheckApi | null,
        payload?: {
            value: true
        }
    ) => {
        domainConnectInfo: EmailDomainConnectCheckApi | null
        payload?: {
            value: true
        }
    }
    openDomainConnect: (providerEndpoint?: string) => {
        providerEndpoint: string | undefined
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface domainConnectLogicMeta {
    key: string
    __keaTypeGenInternalSelectorTypes: {
        autoDetected: (domainConnectInfo: any) => boolean
        providerName: (domainConnectInfo: any) => DomainConnectProviderName | null
        availableProviders: (domainConnectInfo: any) => DomainConnectProvider[]
        hasAnyOption: (autoDetected: boolean, availableProviders: DomainConnectProvider[]) => boolean
    }
}

export type domainConnectLogicType = MakeLogicType<
    domainConnectLogicValues,
    domainConnectLogicActions,
    DomainConnectLogicProps,
    domainConnectLogicMeta
>

function openBlankProviderTab(): Window | null {
    const providerTab = window.open('', '_blank')
    if (providerTab) {
        providerTab.opener = null
    }
    return providerTab
}

function sendProviderTabTo(providerTab: Window | null, url: string): void {
    if (providerTab) {
        providerTab.location.href = url
    } else {
        window.location.assign(url)
    }
}

export const domainConnectLogic = kea<domainConnectLogicType>([
    path((key) => ['lib', 'components', 'DomainConnect', 'domainConnectLogic', key]),
    props({} as DomainConnectLogicProps),
    key(({ logicKey }) => logicKey),
    actions({
        openDomainConnect: (providerEndpoint?: string) => ({ providerEndpoint }),
        checkDomain: true,
    }),
    loaders(({ props }) => ({
        domainConnectInfo: {
            checkDomain: async (): Promise<DomainConnectInfo | null> => {
                if (!props.domain) {
                    return null
                }
                return api.integrations.domainConnectCheck(props.domain)
            },
        },
    })),
    selectors({
        autoDetected: [
            (s) => [s.domainConnectInfo],
            (info: DomainConnectInfo | null): boolean => {
                return info?.supported === true
            },
        ],
        providerName: [
            (s) => [s.domainConnectInfo],
            (info: DomainConnectInfo | null): DomainConnectProviderName | null => {
                return (info?.provider_name as DomainConnectProviderName | null) ?? null
            },
        ],
        availableProviders: [
            (s) => [s.domainConnectInfo],
            (info: DomainConnectInfo | null): DomainConnectProvider[] => {
                return (info?.available_providers as DomainConnectProvider[] | undefined) ?? []
            },
        ],
        hasAnyOption: [
            (s) => [s.autoDetected, s.availableProviders],
            (autoDetected: boolean, providers: DomainConnectProvider[]): boolean => {
                return autoDetected || providers.length > 0
            },
        ],
    }),
    listeners(({ props }) => ({
        openDomainConnect: async ({ providerEndpoint }) => {
            const providerTab = openBlankProviderTab()
            const currentUrl = window.location.href.split('?')[0]
            const redirectUri = `${currentUrl}?domain_connect=${props.context}`

            try {
                const { url } = await api.integrations.domainConnectApplyUrl({
                    context: props.context,
                    integration_id: props.integrationId,
                    proxy_record_id: props.proxyRecordId,
                    redirect_uri: redirectUri,
                    provider_endpoint: providerEndpoint,
                })
                sendProviderTabTo(providerTab, url)
            } catch (e) {
                providerTab?.close()
                if (e instanceof ApiError) {
                    lemonToast.error(`Failed to generate Domain Connect URL: ${e.detail || 'Please try again.'}`)
                } else {
                    lemonToast.error('Failed to generate Domain Connect URL. Please configure DNS manually.')
                }
            }
        },
    })),
    afterMount(({ props, actions }) => {
        if (props.domain) {
            actions.checkDomain()
        }

        // Handle return from Domain Connect redirect
        const searchParams = new URLSearchParams(window.location.search)
        if (searchParams.get('domain_connect') === props.context) {
            lemonToast.success('DNS records have been submitted. It may take a few minutes for changes to propagate.')

            // Remove key to avoid showing the banner again if the user returns to the page before DNS changes have propagated. The user can always trigger the banner again by adding ?domain_connect=email or ?domain_connect=proxy to the URL.
            const url = new URL(window.location.href)
            url.searchParams.delete('domain_connect')
            router.actions.replace(url.pathname + url.search)
        }
    }),
])