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.

18.6 KB
Raw Blame
import type { Monaco } from '@monaco-editor/react'
import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, props, reducers, selectors } from 'kea'
import { router, urlToAction } from 'kea-router'
import type { editor } from 'monaco-editor'
import posthog from 'posthog-js'

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

import api from 'lib/api'
import { databaseTableListLogic } from 'scenes/data-management/database/databaseTableListLogic'
import type { DataWarehouseSavedQuerySummary } from 'scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic'
import { urls } from 'scenes/urls'

import {
    DatabaseSchemaMaterializedViewTable,
    DatabaseSchemaTable,
    DatabaseSchemaViewTable,
    DatabaseSerializedFieldType,
    HogQLQuery,
    NodeKind,
} from '~/queries/schema/schema-general'

import type {
    DatabaseSchemaDataWarehouseTable,
    DatabaseSchemaEndpointTable,
    DatabaseSchemaManagedViewTable,
    DatabaseSchemaQueryResponse,
} from '../../../queries/schema/schema-general'
import { dataWarehouseViewsLogic } from '../saved_queries/dataWarehouseViewsLogic'

export interface DataWarehouseSceneLogicProps {
    monaco?: Monaco | null
    editor?: editor.IStandaloneCodeEditor | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataWarehouseSettingsSceneLogicValues {
    dataWarehouseSavedQueriesLoading: boolean // dataWarehouseViewsLogic
    dataWarehouseSavedQueryMapById: Record<string, DataWarehouseSavedQuerySummary> // dataWarehouseViewsLogic
    dataWarehouseTables: DatabaseSchemaDataWarehouseTable[] // databaseTableListLogic
    database: Required<DatabaseSchemaQueryResponse> | null // databaseTableListLogic
    databaseLoading: boolean // databaseTableListLogic
    externalDataSourceTables: DatabaseSchemaDataWarehouseTable[] // databaseTableListLogic
    posthogTables: DatabaseSchemaTable[] // databaseTableListLogic
    views: DatabaseSchemaViewTable[] // databaseTableListLogic
    viewsMapById: Record<string, DatabaseSchemaEndpointTable | DatabaseSchemaManagedViewTable | DatabaseSchemaViewTable> // databaseTableListLogic
    dataWarehouseTablesAndViews: DatabaseSchemaTable[]
    dataWarehouseTablesBySourceType: Record<string, DatabaseSchemaTable[]>
    editSchemaIsLoading: boolean
    editingView: string | null
    inEditSchemaMode: boolean
    isEditingSavedQuery: boolean
    materializedViews: DatabaseSchemaMaterializedViewTable[]
    materializedViewsLoading: boolean
    nonMaterializedViews: DatabaseSchemaTable[]
    schemaModalIsOpen: boolean
    schemaUpdates: Record<string, DatabaseSerializedFieldType>
    selectedRow: DatabaseSchemaTable | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataWarehouseSettingsSceneLogicActions {
    deleteDataWarehouseSavedQuery: (viewId: string) => string // dataWarehouseViewsLogic
    updateDataWarehouseSavedQuery: (
        view: import('scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic').DataWarehouseSavedQueryUpdate
    ) => import('scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic').DataWarehouseSavedQueryUpdate // dataWarehouseViewsLogic
    updateDataWarehouseSavedQuerySuccess: (
        dataWarehouseSavedQueries: DataWarehouseSavedQuerySummary[],
        payload?:
            | import('scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic').DataWarehouseSavedQueryUpdate
            | undefined
    ) => {
        dataWarehouseSavedQueries: DataWarehouseSavedQuerySummary[]
        payload?: import('scenes/data-warehouse/saved_queries/dataWarehouseViewsLogic').DataWarehouseSavedQueryUpdate
    } // dataWarehouseViewsLogic
    ensureAllTableFields: () => {
        value: true
    } // databaseTableListLogic
    loadDatabase: (
        args_0?:
            | {
                  force?: boolean
                  shallow?: boolean
              }
            | undefined
    ) => {
        force?: boolean
        shallow?: boolean
    } // databaseTableListLogic
    loadDatabaseFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    } // databaseTableListLogic
    loadDatabaseSuccess: (
        database: Required<DatabaseSchemaQueryResponse> | null,
        payload?:
            | {
                  force?: boolean
                  shallow?: boolean
              }
            | undefined
    ) => {
        database: Required<DatabaseSchemaQueryResponse> | null
        payload?: {
            force?: boolean
            shallow?: boolean
        }
    } // databaseTableListLogic
    refreshDatabaseSchema: () => {
        value: true
    } // databaseTableListLogic
    cancelEditSchema: () => {
        database: Required<DatabaseSchemaQueryResponse> | null
    }
    deleteDataWarehouseTable: (tableId: string) => {
        tableId: string
    }
    saveSchema: () => {
        value: true
    }
    selectRow: (row: DatabaseSchemaTable | null) => {
        row: DatabaseSchemaTable | null
    }
    setEditSchemaIsLoading: (isLoading: boolean) => {
        isLoading: boolean
    }
    setEditingView: (id: string | null) => {
        id: string | null
    }
    setIsEditingSavedQuery: (isEditingSavedQuery: boolean) => {
        isEditingSavedQuery: boolean
    }
    toggleEditSchemaMode: (inEditSchemaMode?: boolean) => {
        inEditSchemaMode: boolean | undefined
    }
    toggleSchemaModal: () => {
        value: true
    }
    updateSelectedSchema: (
        columnKey: string,
        columnType: DatabaseSerializedFieldType
    ) => {
        columnKey: string
        columnType: DatabaseSerializedFieldType
    }
    updateView: (
        query: string,
        types: string[][]
    ) => {
        query: string
        types: string[][]
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataWarehouseSettingsSceneLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        dataWarehouseTablesBySourceType: (
            dataWarehouseTables: DatabaseSchemaDataWarehouseTable[]
        ) => Record<string, DatabaseSchemaTable[]>
        dataWarehouseTablesAndViews: (
            dataWarehouseTables: DatabaseSchemaDataWarehouseTable[],
            views: DatabaseSchemaViewTable[]
        ) => DatabaseSchemaTable[]
        nonMaterializedViews: (
            views: DatabaseSchemaViewTable[],
            dataWarehouseSavedQueryMapById: Record<string, DataWarehouseSavedQuerySummary>
        ) => DatabaseSchemaTable[]
        materializedViewsLoading: (databaseLoading: boolean, dataWarehouseSavedQueriesLoading: boolean) => boolean
        materializedViews: (
            views: DatabaseSchemaViewTable[],
            dataWarehouseSavedQueryMapById: Record<string, DataWarehouseSavedQuerySummary>
        ) => DatabaseSchemaMaterializedViewTable[]
    }
}

export type dataWarehouseSettingsSceneLogicType = MakeLogicType<
    dataWarehouseSettingsSceneLogicValues,
    dataWarehouseSettingsSceneLogicActions,
    DataWarehouseSceneLogicProps,
    dataWarehouseSettingsSceneLogicMeta
>

export const dataWarehouseSettingsSceneLogic = kea<dataWarehouseSettingsSceneLogicType>([
    path(['scenes', 'data-warehouse', 'settings', 'dataWarehouseSceneLogic']),
    props({} as DataWarehouseSceneLogicProps),
    connect(() => ({
        values: [
            databaseTableListLogic,
            [
                'database',
                'posthogTables',
                'dataWarehouseTables',
                'externalDataSourceTables',
                'databaseLoading',
                'views',
                'viewsMapById',
            ],
            dataWarehouseViewsLogic,
            ['dataWarehouseSavedQueryMapById', 'dataWarehouseSavedQueriesLoading'],
        ],
        actions: [
            dataWarehouseViewsLogic,
            ['deleteDataWarehouseSavedQuery', 'updateDataWarehouseSavedQuery', 'updateDataWarehouseSavedQuerySuccess'],
            databaseTableListLogic,
            [
                'loadDatabase',
                'refreshDatabaseSchema',
                'loadDatabaseSuccess',
                'loadDatabaseFailure',
                'ensureAllTableFields',
            ],
        ],
    })),
    actions(({ values }) => ({
        selectRow: (row: DatabaseSchemaTable | null) => ({ row }),
        setIsEditingSavedQuery: (isEditingSavedQuery: boolean) => ({ isEditingSavedQuery }),
        toggleEditSchemaMode: (inEditSchemaMode?: boolean) => ({ inEditSchemaMode }),
        updateSelectedSchema: (columnKey: string, columnType: DatabaseSerializedFieldType) => ({
            columnKey,
            columnType,
        }),
        saveSchema: true,
        setEditSchemaIsLoading: (isLoading: boolean) => ({ isLoading }),
        cancelEditSchema: () => ({ database: values.database }),
        deleteDataWarehouseTable: (tableId: string) => ({ tableId }),
        toggleSchemaModal: true,
        setEditingView: (id: string | null) => ({ id }),
        updateView: (query: string, types: string[][]) => ({ query, types }),
    })),
    reducers({
        selectedRow: [
            null as DatabaseSchemaTable | null,
            {
                selectRow: (_, { row }) => row,
                updateSelectedSchema: (state, { columnKey, columnType }) => {
                    if (!state) {
                        return state
                    }

                    const newState = { ...state }

                    const column = newState?.fields[columnKey]
                    if (!column) {
                        return state
                    }

                    column.type = columnType
                    return newState
                },
                loadDatabaseSuccess: (state, { database }) => {
                    if (!state || !database) {
                        return state
                    }

                    const table = Object.values(database.tables).find((n) => n.id === state.id)
                    if (!table) {
                        return state
                    }

                    return table
                },
                cancelEditSchema: (state, { database }) => {
                    if (!state || !database) {
                        return state
                    }

                    const table = Object.values(database.tables).find((n) => n.id === state.id)

                    if (!table) {
                        return state
                    }

                    return JSON.parse(JSON.stringify(table))
                },
            },
        ],
        schemaUpdates: [
            {} as Record<string, DatabaseSerializedFieldType>,
            {
                updateSelectedSchema: (state, { columnKey, columnType }) => {
                    const newState = { ...state }

                    newState[columnKey] = columnType
                    return newState
                },
                toggleEditSchemaMode: () => ({}),
            },
        ],
        isEditingSavedQuery: [
            false,
            {
                setIsEditingSavedQuery: (_, { isEditingSavedQuery }) => isEditingSavedQuery,
            },
        ],
        inEditSchemaMode: [
            false as boolean,
            {
                toggleEditSchemaMode: (state, { inEditSchemaMode }) => {
                    if (inEditSchemaMode !== undefined) {
                        return inEditSchemaMode
                    }

                    return !state
                },
            },
        ],
        editSchemaIsLoading: [
            false as boolean,
            {
                setEditSchemaIsLoading: (_, { isLoading }) => isLoading,
                loadDatabaseSuccess: () => false,
                loadDatabaseFailure: () => false,
            },
        ],
        schemaModalIsOpen: [
            false,
            {
                toggleSchemaModal: (state) => !state,
            },
        ],
        editingView: [
            null as string | null,
            {
                setEditingView: (_, { id }) => id,
            },
        ],
    }),
    selectors({
        dataWarehouseTablesBySourceType: [
            (s) => [s.dataWarehouseTables],
            (
                dataWarehouseTables: import('~/queries/schema/schema-general').DatabaseSchemaDataWarehouseTable[]
            ): Record<string, DatabaseSchemaTable[]> => {
                return dataWarehouseTables.reduce((acc: Record<string, DatabaseSchemaTable[]>, table) => {
                    const group = table.source?.source_type ?? 'S3'
                    acc[group] ??= []
                    acc[group].push(table)

                    return acc
                }, {})
            },
        ],
        dataWarehouseTablesAndViews: [
            (s) => [s.dataWarehouseTables, s.views],
            (
                dataWarehouseTables: import('~/queries/schema/schema-general').DatabaseSchemaDataWarehouseTable[],
                views: DatabaseSchemaViewTable[]
            ): DatabaseSchemaTable[] => {
                return [...dataWarehouseTables, ...views]
            },
        ],
        nonMaterializedViews: [
            (s) => [s.views, s.dataWarehouseSavedQueryMapById],
            (
                views: DatabaseSchemaViewTable[],
                dataWarehouseSavedQueryMapById: Record<string, DataWarehouseSavedQuerySummary>
            ): DatabaseSchemaTable[] => {
                return views
                    .filter((view) => !dataWarehouseSavedQueryMapById[view.id]?.is_materialized)
                    .map((view) => ({
                        ...view,
                        type: 'view',
                    }))
            },
        ],
        // `materializedViews` needs both loaders: names come from the database schema, the
        // materialized flag from the saved queries. Consumers that watch only one report an empty
        // list while the other is still in flight.
        materializedViewsLoading: [
            (s) => [s.databaseLoading, s.dataWarehouseSavedQueriesLoading],
            (databaseLoading: boolean, dataWarehouseSavedQueriesLoading: boolean): boolean =>
                databaseLoading || dataWarehouseSavedQueriesLoading,
        ],
        materializedViews: [
            (s) => [s.views, s.dataWarehouseSavedQueryMapById],
            (
                views: DatabaseSchemaViewTable[],
                dataWarehouseSavedQueryMapById: Record<string, DataWarehouseSavedQuerySummary>
            ): DatabaseSchemaMaterializedViewTable[] => {
                return views
                    .filter((view) => dataWarehouseSavedQueryMapById[view.id]?.is_materialized)
                    .map((view) => ({
                        ...view,
                        type: 'materialized_view',
                        last_run_at: dataWarehouseSavedQueryMapById[view.id]?.last_run_at,
                        status: dataWarehouseSavedQueryMapById[view.id]?.status,
                    }))
            },
        ],
    }),
    listeners(({ actions, values }) => ({
        deleteDataWarehouseSavedQuery: () => {
            // dataWarehouseViewsLogic owns the delete request and its success toast. Here we only
            // clear the selected row; the schema refresh happens in that logic's success handler.
            actions.selectRow(null)
        },
        selectRow: () => {
            actions.setIsEditingSavedQuery(false)
        },
        updateDataWarehouseSavedQuerySuccess: async ({ payload }) => {
            lemonToast.success(`${payload?.name ?? 'View'} successfully updated`)
            if (payload) {
                router.actions.push(urls.sqlEditor({ view_id: payload.id }))
            }
        },
        saveSchema: async () => {
            const schemaUpdates = values.schemaUpdates
            const tableId = values.selectedRow?.id

            if (!tableId) {
                return
            }

            if (Object.keys(schemaUpdates).length === 0) {
                actions.toggleEditSchemaMode()
                return
            }

            actions.setEditSchemaIsLoading(true)

            try {
                await api.dataWarehouseTables.updateSchema(tableId, schemaUpdates)
                actions.refreshDatabaseSchema()

                if (values.selectedRow) {
                    posthog.capture('source schema saved', {
                        name: values.selectedRow.name,
                        tableType: values.selectedRow.type,
                    })
                }
            } catch (e: any) {
                lemonToast.error(e.message)
                actions.setEditSchemaIsLoading(false)
            }
        },
        loadDatabaseSuccess: () => {
            if (values.inEditSchemaMode) {
                actions.toggleEditSchemaMode()
            }
        },
        loadDatabaseFailure: () => {
            if (values.inEditSchemaMode) {
                actions.toggleEditSchemaMode()
            }
        },
        cancelEditSchema: () => {
            actions.toggleEditSchemaMode(false)
        },
        deleteDataWarehouseTable: async ({ tableId }) => {
            await api.dataWarehouseTables.delete(tableId)
            actions.selectRow(null)
            lemonToast.success('Table successfully deleted')
        },
        toggleSchemaModal: () => {
            if (values.schemaModalIsOpen && values.selectedRow) {
                posthog.capture('source schema viewed', {
                    name: values.selectedRow.name,
                    tableType: values.selectedRow.type,
                })
            }
        },
        updateView: ({ query, types }) => {
            if (values.editingView) {
                const newViewQuery: HogQLQuery = {
                    kind: NodeKind.HogQLQuery,
                    query: query,
                }

                const oldView = values.viewsMapById[values.editingView]
                if (oldView.type === 'view') {
                    // Should always be `view`, but assert at the TS level
                    const newView: DatabaseSchemaViewTable & { types: string[][] } = {
                        ...oldView,
                        query: newViewQuery,
                        types,
                    }
                    actions.updateDataWarehouseSavedQuery(newView)
                }
            }
        },
    })),
    urlToAction(({ actions }) => ({
        '/data-warehouse/view/:id': ({ id }) => {
            actions.setEditingView(id as string)
        },
        '/data-warehouse': () => {
            actions.setEditingView(null)
        },
    })),
    afterMount(({ actions, values }) => {
        if (!values.database && !values.databaseLoading) {
            actions.loadDatabase()
        } else {
            // The store may hold a shallow (fields-less) schema left by the SQL editor; the schema
            // editing panel and the taxonomic data warehouse groups need fields.
            actions.ensureAllTableFields()
        }
    }),
])