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.

15.1 KB
Raw Blame
import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { actionToUrl, router, urlToAction } from 'kea-router'

import { lemonToast } from '@posthog/lemon-ui'

import { ApiError } from 'lib/api'
import { listAllPages } from 'scenes/settings/environment/cloudEnvironmentsLogic'
import { teamLogic } from 'scenes/teamLogic'
import { urls } from 'scenes/urls'

import {
    messagingSupabaseAuthEmailsSettingsDestroy,
    messagingSupabaseAuthEmailsSettingsPartialUpdate,
    messagingSupabaseAuthEmailsSettingsRetrieve,
    messagingSupabaseAuthEmailsStarterTemplatesCreate,
    messagingTemplatesList,
} from 'products/messaging/frontend/generated/api'
import type {
    MessageTemplateApi,
    PatchedSupabaseAuthEmailSettingsUpdateApi,
    SupabaseAuthEmailSettingsApi,
    SupabaseEmailTypeApi,
} from 'products/messaging/frontend/generated/api.schemas'

export type SupabaseAuthEmailsStatus = 'connected' | 'incomplete' | 'not-set-up'

// `?setup=supabase` on a Channels tab opens the setup modal, so the agent skill and docs can link straight to it.
const SETUP_PARAM = 'setup'
const SETUP_PARAM_VALUE = 'supabase'

function errorMessage(error: unknown, fallback: string): string {
    return error instanceof ApiError && error.detail ? error.detail : fallback
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface supabaseAuthEmailsLogicValues {
    currentTeamIdStrict: number | string // teamLogic
    connectionChanged: boolean
    hookSecret: string
    isSetupOpen: boolean
    missingStarterTypes: SupabaseEmailTypeApi[] | null
    settings: SupabaseAuthEmailSettingsApi | null
    settingsLoadFailed: boolean
    settingsLoading: boolean
    status: SupabaseAuthEmailsStatus | null
    supabaseUrl: string
    templates: MessageTemplateApi[] | null
    templatesLoadFailed: boolean
    templatesLoading: boolean
    transactionalTemplates: MessageTemplateApi[] | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface supabaseAuthEmailsLogicActions {
    closeSetup: () => {
        value: true
    }
    createStarterTemplates: () => any
    createStarterTemplatesFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    createStarterTemplatesSuccess: (
        settings: SupabaseAuthEmailSettingsApi,
        payload?: any
    ) => {
        settings: SupabaseAuthEmailSettingsApi
        payload?: any
    }
    disconnect: () => any
    disconnectFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    disconnectSuccess: (
        settings: SupabaseAuthEmailSettingsApi,
        payload?: any
    ) => {
        settings: SupabaseAuthEmailSettingsApi
        payload?: any
    }
    loadSettings: () => any
    loadSettingsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadSettingsSuccess: (
        settings: SupabaseAuthEmailSettingsApi,
        payload?: any
    ) => {
        settings: SupabaseAuthEmailSettingsApi
        payload?: any
    }
    loadTemplates: () => any
    loadTemplatesFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadTemplatesSuccess: (
        templates: MessageTemplateApi[],
        payload?: any
    ) => {
        templates: MessageTemplateApi[]
        payload?: any
    }
    openSetup: () => {
        value: true
    }
    saveConnection: () => {
        value: true
    }
    saveSettings: (patch: PatchedSupabaseAuthEmailSettingsUpdateApi) => PatchedSupabaseAuthEmailSettingsUpdateApi
    saveSettingsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    saveSettingsSuccess: (
        settings: SupabaseAuthEmailSettingsApi,
        payload?: PatchedSupabaseAuthEmailSettingsUpdateApi
    ) => {
        settings: SupabaseAuthEmailSettingsApi
        payload?: PatchedSupabaseAuthEmailSettingsUpdateApi
    }
    setHookSecret: (hookSecret: string) => {
        hookSecret: string
    }
    setSupabaseUrl: (supabaseUrl: string) => {
        supabaseUrl: string
    }
    setTemplate: (
        emailType: string,
        templateId: string | null
    ) => {
        emailType: string
        templateId: string | null
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface supabaseAuthEmailsLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        status: (settings: SupabaseAuthEmailSettingsApi | null) => SupabaseAuthEmailsStatus | null
        transactionalTemplates: (templates: MessageTemplateApi[] | null) => MessageTemplateApi[] | null
        missingStarterTypes: (
            settings: SupabaseAuthEmailSettingsApi | null,
            transactionalTemplates: MessageTemplateApi[] | null,
            templatesLoading: boolean
        ) => SupabaseEmailTypeApi[] | null
        connectionChanged: (
            settings: SupabaseAuthEmailSettingsApi | null,
            supabaseUrl: string,
            hookSecret: string
        ) => boolean
    }
}

export type supabaseAuthEmailsLogicType = MakeLogicType<
    supabaseAuthEmailsLogicValues,
    supabaseAuthEmailsLogicActions,
    Record<string, any>,
    supabaseAuthEmailsLogicMeta
>

export const supabaseAuthEmailsLogic = kea<supabaseAuthEmailsLogicType>([
    path(['products', 'workflows', 'frontend', 'SupabaseAuthEmails', 'supabaseAuthEmailsLogic']),
    connect(() => ({
        values: [teamLogic, ['currentTeamIdStrict']],
    })),
    actions({
        setSupabaseUrl: (supabaseUrl: string) => ({ supabaseUrl }),
        setHookSecret: (hookSecret: string) => ({ hookSecret }),
        saveConnection: true,
        setTemplate: (emailType: string, templateId: string | null) => ({ emailType, templateId }),
        openSetup: true,
        closeSetup: true,
    }),
    loaders(({ values, cache }) => ({
        // null until the first load answers, so the form never renders from settings nobody asked for.
        settings: [
            null as SupabaseAuthEmailSettingsApi | null,
            {
                loadSettings: async () =>
                    await messagingSupabaseAuthEmailsSettingsRetrieve(String(values.currentTeamIdStrict)),
                saveSettings: async (patch: PatchedSupabaseAuthEmailSettingsUpdateApi) =>
                    await messagingSupabaseAuthEmailsSettingsPartialUpdate(String(values.currentTeamIdStrict), patch),
                disconnect: async () =>
                    await messagingSupabaseAuthEmailsSettingsDestroy(String(values.currentTeamIdStrict)),
                createStarterTemplates: async () => {
                    // The success toast compares against this to say how many templates the call made.
                    cache.templatesBeforeStarter = values.settings?.templates ?? {}
                    return await messagingSupabaseAuthEmailsStarterTemplatesCreate(String(values.currentTeamIdStrict))
                },
            },
        ],
        templates: [
            null as MessageTemplateApi[] | null,
            {
                // Every page, so a mapped template past the first page still shows by name in the picker.
                loadTemplates: async () =>
                    await listAllPages((params) => messagingTemplatesList(String(values.currentTeamIdStrict), params)),
            },
        ],
    })),
    reducers({
        isSetupOpen: [
            false,
            {
                openSetup: () => true,
                closeSetup: () => false,
            },
        ],
        supabaseUrl: [
            '',
            {
                setSupabaseUrl: (_, { supabaseUrl }) => supabaseUrl,
                loadSettingsSuccess: (_, { settings }) => settings.supabase_url,
                // A save that only maps templates must not drop a URL the user is still typing.
                saveSettingsSuccess: (state, { settings, payload }) =>
                    payload && 'supabase_url' in payload ? settings.supabase_url : state,
                disconnectSuccess: () => '',
            },
        ],
        // The stored secret is write-only, so this only ever holds a new one being typed.
        hookSecret: [
            '',
            {
                setHookSecret: (_, { hookSecret }) => hookSecret,
                saveSettingsSuccess: (state, { payload }) => (payload?.hook_secret ? '' : state),
                disconnectSuccess: () => '',
            },
        ],
        templatesLoadFailed: [
            false,
            {
                loadTemplates: () => false,
                loadTemplatesFailure: () => true,
            },
        ],
        // A failed load is its own screen, not an empty form.
        settingsLoadFailed: [
            false,
            {
                loadSettings: () => false,
                loadSettingsFailure: () => true,
            },
        ],
    }),
    selectors({
        status: [
            (s) => [s.settings],
            (settings: SupabaseAuthEmailSettingsApi | null): SupabaseAuthEmailsStatus | null => {
                if (!settings) {
                    return null
                }
                if (settings.supabase_url && settings.has_hook_secret) {
                    return 'connected'
                }
                const started =
                    !!settings.supabase_url || settings.has_hook_secret || Object.keys(settings.templates).length > 0
                return started ? 'incomplete' : 'not-set-up'
            },
        ],
        transactionalTemplates: [
            (s) => [s.templates],
            (templates: MessageTemplateApi[] | null): MessageTemplateApi[] | null =>
                // Only sensitive templates keep sign-in codes and reset links out of stored emails, and the API
                // refuses any other.
                templates?.filter(
                    (template: MessageTemplateApi) =>
                        template.transactional_hog_flow_id && template.sensitive && !template.deleted
                ) ?? null,
        ],
        // Null while the template list is unknown. The endpoint skips types that already have a template anyway.
        missingStarterTypes: [
            (s) => [s.settings, s.transactionalTemplates, s.templatesLoading],
            (
                settings: SupabaseAuthEmailSettingsApi | null,
                transactionalTemplates: MessageTemplateApi[] | null,
                templatesLoading: boolean
            ): SupabaseEmailTypeApi[] | null => {
                if (!settings || !transactionalTemplates || templatesLoading) {
                    return null
                }
                // Same rule as the endpoint: a mapping to a deleted or non-sensitive template counts as missing.
                const usable = new Set(transactionalTemplates.map((template) => template.id))
                return settings.email_types.filter(
                    (type) => type.has_starter_template && !usable.has(settings.templates[type.value])
                )
            },
        ],
        connectionChanged: [
            (s) => [s.settings, s.supabaseUrl, s.hookSecret],
            (settings: SupabaseAuthEmailSettingsApi | null, supabaseUrl: string, hookSecret: string): boolean =>
                !!settings && (supabaseUrl.trim() !== settings.supabase_url || hookSecret.trim() !== ''),
        ],
    }),
    listeners(({ actions, values, cache }) => ({
        saveConnection: () => {
            const patch: PatchedSupabaseAuthEmailSettingsUpdateApi = { supabase_url: values.supabaseUrl.trim() }
            if (values.hookSecret.trim()) {
                patch.hook_secret = values.hookSecret.trim()
            }
            actions.saveSettings(patch)
        },
        setTemplate: ({ emailType, templateId }) => {
            if (!values.settings) {
                return
            }
            const templates = { ...values.settings.templates }
            if (templateId) {
                templates[emailType] = templateId
            } else {
                delete templates[emailType]
            }
            actions.saveSettings({ templates })
        },
        createStarterTemplatesSuccess: ({ settings }) => {
            const before: Record<string, string> = cache.templatesBeforeStarter ?? {}
            const created = Object.entries(settings.templates).filter(([type, id]) => before[type] !== id).length
            if (created === 0) {
                lemonToast.info('Every email already has a template, so nothing was created')
                return
            }
            lemonToast.success(created === 1 ? 'Created 1 starter template' : `Created ${created} starter templates`)
            actions.loadTemplates()
        },
        saveSettingsFailure: ({ errorObject }) => {
            lemonToast.error(errorMessage(errorObject, "Couldn't save the Supabase settings. Try again."))
        },
        disconnectSuccess: () => {
            lemonToast.success('Disconnected your Supabase project')
            actions.closeSetup()
        },
        disconnectFailure: ({ errorObject }) => {
            lemonToast.error(errorMessage(errorObject, "Couldn't disconnect your Supabase project. Try again."))
        },
        createStarterTemplatesFailure: ({ errorObject }) => {
            lemonToast.error(errorMessage(errorObject, "Couldn't create the starter templates. Try again."))
        },
        // The card only needs the settings, so the template list waits until someone opens the setup.
        openSetup: () => {
            // Each open starts from what is saved, so a draft left by an earlier close never gets saved by mistake.
            actions.setSupabaseUrl(values.settings?.supabase_url ?? '')
            actions.setHookSecret('')
            if (values.templates === null && !values.templatesLoading) {
                actions.loadTemplates()
            }
        },
    })),
    actionToUrl(() => ({
        // A history entry, so the back button closes the setup.
        openSetup: () => [
            router.values.location.pathname,
            { ...router.values.searchParams, [SETUP_PARAM]: SETUP_PARAM_VALUE },
            router.values.hashParams,
        ],
        closeSetup: () => {
            const { [SETUP_PARAM]: _, ...searchParams } = router.values.searchParams
            return [router.values.location.pathname, searchParams, router.values.hashParams, { replace: true }]
        },
    })),
    urlToAction(({ actions, values }) => {
        const syncSetupWithUrl = (_: Record<string, string | undefined>, searchParams: Record<string, any>): void => {
            const wantsSetup = searchParams[SETUP_PARAM] === SETUP_PARAM_VALUE
            if (wantsSetup && !values.isSetupOpen) {
                actions.openSetup()
            } else if (!wantsSetup && values.isSetupOpen) {
                actions.closeSetup()
            }
        }
        return {
            [urls.workflows('channels')]: syncSetupWithUrl,
            [urls.broadcasts('channels')]: syncSetupWithUrl,
            [urls.transactional('channels')]: syncSetupWithUrl,
        }
    }),
    afterMount(({ actions }) => {
        actions.loadSettings()
    }),
])