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.

9.6 KB
Raw Blame
import { MakeLogicType, actions, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import posthog from 'posthog-js'

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

import api, { ApiError, PaginatedResponse } from 'lib/api'

import { HogQLQuery } from '~/queries/schema/schema-general'
import { DataWarehouseSavedQueryDraft } from '~/types'

import { QueryTab } from './sqlEditorLogic'

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface draftsLogicValues {
    drafts: DataWarehouseSavedQueryDraft[]
    draftsResponse: PaginatedResponse<DataWarehouseSavedQueryDraft>
    draftsResponseLoading: boolean
    hasMoreDrafts: boolean
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface draftsLogicActions {
    deleteDraft: (
        draftId: string,
        viewName?: string
    ) => {
        draftId: string
        viewName: string | undefined
    }
    deleteDraftSuccess: (
        draftId: string,
        viewName?: string
    ) => {
        draftId: string
        viewName: string | undefined
    }
    loadDrafts: () => any
    loadDraftsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadDraftsSuccess: (
        draftsResponse: PaginatedResponse<DataWarehouseSavedQueryDraft>,
        payload?: any
    ) => {
        draftsResponse: PaginatedResponse<DataWarehouseSavedQueryDraft>
        payload?: any
    }
    loadMoreDrafts: () => any
    loadMoreDraftsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadMoreDraftsSuccess: (
        draftsResponse: PaginatedResponse<DataWarehouseSavedQueryDraft>,
        payload?: any
    ) => {
        draftsResponse: PaginatedResponse<DataWarehouseSavedQueryDraft>
        payload?: any
    }
    renameDraft: (
        draftId: string,
        name: string
    ) => {
        draftId: string
        name: string
    }
    saveAsDraft: (
        query: HogQLQuery,
        viewId: string,
        tab: QueryTab
    ) => {
        query: HogQLQuery
        tab: QueryTab
        viewId: string
    }
    saveAsDraftSuccess: (
        draft: DataWarehouseSavedQueryDraft,
        tab: QueryTab
    ) => {
        draft: DataWarehouseSavedQueryDraft
        tab: QueryTab
    }
    saveOrUpdateDraft: (
        query: HogQLQuery,
        viewId?: string,
        draftId?: string,
        activeTab?: QueryTab
    ) => {
        activeTab: QueryTab | undefined
        draftId: string | undefined
        query: HogQLQuery
        viewId: string | undefined
    }
    setDrafts: (drafts: DataWarehouseSavedQueryDraft[]) => {
        drafts: DataWarehouseSavedQueryDraft[]
    }
    updateDraft: (draft: DataWarehouseSavedQueryDraft) => {
        draft: DataWarehouseSavedQueryDraft
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface draftsLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        hasMoreDrafts: (draftsResponse: PaginatedResponse<DataWarehouseSavedQueryDraft>) => boolean
    }
}

export type draftsLogicType = MakeLogicType<draftsLogicValues, draftsLogicActions, Record<string, any>, draftsLogicMeta>

export const draftsLogic = kea<draftsLogicType>([
    path(['scenes', 'data-warehouse', 'editor', 'draftsLogic']),

    actions({
        saveAsDraft: (query: HogQLQuery, viewId: string, tab: QueryTab) => ({
            query,
            viewId,
            tab,
        }),
        updateDraft: (draft: DataWarehouseSavedQueryDraft) => ({ draft }),
        saveOrUpdateDraft: (query: HogQLQuery, viewId?: string, draftId?: string, activeTab?: QueryTab) => ({
            query,
            viewId,
            draftId,
            activeTab,
        }),
        deleteDraft: (draftId: string, viewName?: string) => ({ draftId, viewName }),
        deleteDraftSuccess: (draftId: string, viewName?: string) => ({ draftId, viewName }),
        setDrafts: (drafts: DataWarehouseSavedQueryDraft[]) => ({ drafts }),
        renameDraft: (draftId: string, name: string) => ({ draftId, name }),
        saveAsDraftSuccess: (draft: DataWarehouseSavedQueryDraft, tab: QueryTab) => ({ draft, tab }),
    }),

    loaders(({ values }) => ({
        draftsResponse: [
            {} as PaginatedResponse<DataWarehouseSavedQueryDraft>,
            {
                loadDrafts: async () => {
                    const drafts = await api.dataWarehouseSavedQueryDrafts.list()

                    return drafts
                },
                loadMoreDrafts: async () => {
                    if (values.draftsResponse.next) {
                        // nosemgrep: prefer-codegen-api -- Legacy raw API call with a URL built at runtime and an unchecked response type. Use a generated function if one covers this endpoint.
                        const drafts = await api.get<PaginatedResponse<DataWarehouseSavedQueryDraft>>(
                            values.draftsResponse.next
                        )

                        return {
                            ...values.draftsResponse,
                            results: [...values.draftsResponse.results, ...drafts.results],
                            next: drafts.next,
                        }
                    }
                    return values.draftsResponse
                },
            },
        ],
    })),
    reducers({
        drafts: [
            [] as DataWarehouseSavedQueryDraft[],
            {
                setDrafts: (_, { drafts }) => drafts,
            },
        ],
    }),
    selectors({
        hasMoreDrafts: [
            (s) => [s.draftsResponse],
            (draftsResponse: PaginatedResponse<DataWarehouseSavedQueryDraft>) => draftsResponse.next !== null,
        ],
    }),
    listeners(({ values, actions }) => ({
        loadDraftsSuccess: ({ draftsResponse }) => {
            actions.setDrafts(draftsResponse.results)
        },
        loadMoreDraftsSuccess: ({ draftsResponse }) => {
            actions.setDrafts(draftsResponse.results)
        },
        saveAsDraft: async ({ query, viewId, tab }) => {
            try {
                const draft = await api.dataWarehouseSavedQueryDrafts.create({
                    query,
                    saved_query_id: viewId,
                    edited_history_id: tab.view?.latest_history_id,
                })
                lemonToast.success('Draft saved')

                const newDrafts = [...values.drafts, draft]
                actions.setDrafts(newDrafts)
                actions.saveAsDraftSuccess(draft, tab)
            } catch (e) {
                const apiError = e as ApiError
                if (apiError) {
                    lemonToast.error(`Draft save failed: ${apiError.message}`)
                }
                posthog.captureException(e)
            }
        },
        updateDraft: async ({ draft }) => {
            try {
                const updatedDraft = await api.dataWarehouseSavedQueryDrafts.update(draft.id, draft)
                lemonToast.success('Draft updated')
                const newDrafts = values.drafts.map((d) => (d.id === draft.id ? updatedDraft : d))
                actions.setDrafts(newDrafts)
            } catch (e) {
                const apiError = e as ApiError
                if (apiError) {
                    lemonToast.error(`Draft update failed: ${apiError.message}`)
                }
                posthog.captureException(e)
            }
        },
        deleteDraft: async ({ draftId, viewName }) => {
            try {
                await api.dataWarehouseSavedQueryDrafts.delete(draftId)
                lemonToast.success('Draft deleted')

                const newDrafts = values.drafts.filter((draft) => draft.id !== draftId)
                actions.setDrafts(newDrafts)
                actions.deleteDraftSuccess(draftId, viewName)
            } catch (e) {
                const apiError = e as ApiError
                if (apiError) {
                    lemonToast.error(`Draft delete failed: ${apiError.message}`)
                }
                posthog.captureException(e)
            }
        },
        renameDraft: async ({ draftId, name }) => {
            await api.dataWarehouseSavedQueryDrafts.update(draftId, { name })
            actions.setDrafts(values.drafts.map((d) => (d.id === draftId ? { ...d, name } : d)))
        },
        saveOrUpdateDraft: async ({ query, viewId, draftId, activeTab }) => {
            if (draftId) {
                try {
                    const updatedDraft = await api.dataWarehouseSavedQueryDrafts.update(draftId, {
                        query,
                    })
                    lemonToast.success('Draft updated')
                    const newDrafts = values.drafts.map((d) => (d.id === draftId ? updatedDraft : d))
                    actions.setDrafts(newDrafts)
                } catch (e) {
                    const apiError = e as ApiError
                    if (apiError) {
                        lemonToast.error(`Draft update failed: ${apiError.message}`)
                    }
                    posthog.captureException(e)
                }
            } else {
                const existingDrafts = await api.dataWarehouseSavedQueryDrafts.list()
                const existingDraft = existingDrafts.results.find((draft) => draft.saved_query_id === viewId)

                if (existingDraft) {
                    actions.updateDraft({
                        ...existingDraft,
                        query,
                    })
                } else if (viewId && activeTab) {
                    actions.saveAsDraft(query, viewId, activeTab)
                }
            }
        },
    })),
])