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.

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

import api from 'lib/api'
import { lemonToast } from 'lib/lemon-ui/LemonToast'
import { deleteWithUndo } from 'lib/utils/deleteWithUndo'
import { teamLogic } from 'scenes/teamLogic'

import { tagsModel } from '~/models/tagsModel'

import { filterMessageTemplates } from './filterMessageTemplates'
import { MessageTemplate } from './types'

export type { MessageTemplate }

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface messageTemplatesLogicValues {
    tags: string[] // tagsModel
    currentTeamIdStrict: number | string // teamLogic
    createdByFilter: number | null
    filteredTemplates: MessageTemplate[]
    search: string
    tagsFilter: string[]
    templates: MessageTemplate[]
    templatesLoading: boolean
    transactionalOnly: boolean
    transactionalTemplates: MessageTemplate[]
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface messageTemplatesLogicActions {
    loadTags: () => {
        value: true
    } // tagsModel
    loadTagsIfNeeded: () => {
        value: true
    } // tagsModel
    createTemplate: ({ template }: { template: Partial<MessageTemplate> }) => {
        template: Partial<MessageTemplate>
    }
    createTemplateFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    createTemplateSuccess: (
        templates: MessageTemplate[],
        payload?: {
            template: Partial<MessageTemplate>
        }
    ) => {
        templates: MessageTemplate[]
        payload?: {
            template: Partial<MessageTemplate>
        }
    }
    deleteTemplate: (template: MessageTemplate) => MessageTemplate
    deleteTemplateFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    deleteTemplateSuccess: (
        templates: MessageTemplate[],
        payload?: MessageTemplate
    ) => {
        templates: MessageTemplate[]
        payload?: MessageTemplate
    }
    duplicateTemplate: (template: MessageTemplate) => MessageTemplate
    duplicateTemplateFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    duplicateTemplateSuccess: (
        templates: MessageTemplate[],
        payload?: MessageTemplate
    ) => {
        templates: MessageTemplate[]
        payload?: MessageTemplate
    }
    loadTemplates: () => any
    loadTemplatesFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadTemplatesSuccess: (
        templates: MessageTemplate[],
        payload?: any
    ) => {
        templates: MessageTemplate[]
        payload?: any
    }
    setCreatedByFilter: (createdBy: number | null) => {
        createdBy: number | null
    }
    setSearch: (search: string) => {
        search: string
    }
    setTagsFilter: (tagsFilter: string[]) => {
        tagsFilter: string[]
    }
    setTransactionalOnly: (transactionalOnly: boolean) => {
        transactionalOnly: boolean
    }
    templateTagsSaved: (template: MessageTemplate) => {
        template: MessageTemplate
    }
    updateTemplate: ({ templateId, template }: { template: Partial<MessageTemplate>; templateId: string }) => {
        templateId: string
        template: Partial<MessageTemplate>
    }
    updateTemplateFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    updateTemplateSuccess: (
        templates: MessageTemplate[],
        payload?: {
            templateId: string
            template: Partial<MessageTemplate>
        }
    ) => {
        templates: MessageTemplate[]
        payload?: {
            templateId: string
            template: Partial<MessageTemplate>
        }
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface messageTemplatesLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        transactionalTemplates: (templates: MessageTemplate[]) => MessageTemplate[]
        filteredTemplates: (
            templates: MessageTemplate[],
            search: string,
            createdByFilter: number | null,
            transactionalOnly: boolean,
            tagsFilter: string[]
        ) => MessageTemplate[]
    }
}

export type messageTemplatesLogicType = MakeLogicType<
    messageTemplatesLogicValues,
    messageTemplatesLogicActions,
    Record<string, any>,
    messageTemplatesLogicMeta
>

export const messageTemplatesLogic = kea<messageTemplatesLogicType>([
    path(['products', 'workflows', 'frontend', 'library', 'messageTemplatesLogic']),
    connect(() => ({
        values: [teamLogic, ['currentTeamIdStrict'], tagsModel, ['tags']],
        actions: [tagsModel, ['loadTags', 'loadTagsIfNeeded']],
    })),
    actions({
        setSearch: (search: string) => ({ search }),
        setCreatedByFilter: (createdBy: number | null) => ({ createdBy }),
        setTransactionalOnly: (transactionalOnly: boolean) => ({ transactionalOnly }),
        setTagsFilter: (tagsFilter: string[]) => ({ tagsFilter }),
        templateTagsSaved: (template: MessageTemplate) => ({ template }),
    }),
    reducers({
        search: ['' as string, { setSearch: (_, { search }) => search }],
        createdByFilter: [null as number | null, { setCreatedByFilter: (_, { createdBy }) => createdBy }],
        transactionalOnly: [false, { setTransactionalOnly: (_, { transactionalOnly }) => transactionalOnly }],
        tagsFilter: [[] as string[], { setTagsFilter: (_, { tagsFilter }) => tagsFilter }],
        templates: [
            [] as MessageTemplate[],
            {
                templateTagsSaved: (state, { template }) =>
                    state.map((t: MessageTemplate) => (t.id === template.id ? template : t)),
            },
        ],
    }),
    loaders(({ values, actions }) => ({
        templates: [
            [] as MessageTemplate[],
            {
                loadTemplates: async () => {
                    const response = await api.messaging.getTemplates()
                    return response.results
                },
                deleteTemplate: async (template: MessageTemplate) => {
                    await deleteWithUndo({
                        endpoint: `environments/${values.currentTeamIdStrict}/messaging_templates`,
                        object: {
                            id: template.id,
                            name: template.name,
                        },
                        callback: (undo) => {
                            if (undo) {
                                actions.loadTemplates()
                            }
                        },
                    })
                    return values.templates.filter((t: MessageTemplate) => t.id !== template.id)
                },
                createTemplate: async ({ template }: { template: Partial<MessageTemplate> }) => {
                    try {
                        const newTemplate = await api.messaging.createTemplate(template)
                        lemonToast.success('Template created successfully')
                        return [...values.templates, newTemplate]
                    } catch {
                        lemonToast.error('Failed to create template')
                        return values.templates
                    }
                },
                updateTemplate: async ({
                    templateId,
                    template,
                }: {
                    templateId: string
                    template: Partial<MessageTemplate>
                }) => {
                    try {
                        const updatedTemplate = await api.messaging.updateTemplate(templateId, template)
                        lemonToast.success('Template updated successfully')
                        return values.templates.map((t: MessageTemplate) => (t.id === templateId ? updatedTemplate : t))
                    } catch {
                        lemonToast.error('Failed to update template')
                        return values.templates
                    }
                },
                duplicateTemplate: async (template: MessageTemplate) => {
                    try {
                        const duplicatedTemplate = await api.messaging.createTemplate({
                            name: `${template.name} (copy)`,
                            description: template.description,
                            content: template.content,
                        })
                        lemonToast.success('Template duplicated successfully')
                        return [...values.templates, duplicatedTemplate]
                    } catch {
                        lemonToast.error('Failed to duplicate template')
                        return values.templates
                    }
                },
            },
        ],
    })),
    selectors({
        transactionalTemplates: [
            (s) => [s.templates],
            (templates: MessageTemplate[]): MessageTemplate[] => templates.filter((t) => !!t.transactional_hog_flow_id),
        ],
        filteredTemplates: [
            (s) => [s.templates, s.search, s.createdByFilter, s.transactionalOnly, s.tagsFilter],
            (
                templates: MessageTemplate[],
                search: string,
                createdByFilter: number | null,
                transactionalOnly: boolean,
                tagsFilter: string[]
            ): MessageTemplate[] =>
                filterMessageTemplates(templates, {
                    search,
                    tags: tagsFilter,
                    createdBy: createdByFilter,
                    transactionalOnly,
                }),
        ],
    }),
    afterMount(({ actions }) => {
        actions.loadTemplates()
        actions.loadTagsIfNeeded()
    }),
])

// A plain function rather than a listener, because the caller awaits it to keep its editor open on
// a rejection, and a kea listener that rethrows raises an unhandled rejection on the way out.
export async function saveTemplateTags(template: MessageTemplate, tags: string[]): Promise<void> {
    const updated = await api.messaging.updateTemplate(template.id, { tags })
    messageTemplatesLogic.findMounted()?.actions.templateTagsSaved(updated)
    tagsModel.findMounted()?.actions.loadTags()
}