: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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()
}
}),
])