: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 {
MakeLogicType,
actions,
afterMount,
connect,
kea,
key,
listeners,
path,
props,
propsChanged,
reducers,
selectors,
sharedListeners,
} from 'kea'
import type { BreakPointFunction } from 'kea'
import { subscriptions } from 'kea-subscriptions'
import mergeObject from 'lodash.merge'
import posthog from 'posthog-js'
import { PART_OF_WHOLE_DISPLAY_TYPES, PIE_DISPLAY_TYPES } from 'lib/constants'
import { dayjs } from 'lib/dayjs'
import type { execHog } from 'lib/hog'
import { RGBToHex, lightenDarkenColor } from 'lib/utils/colors'
import { uuid } from 'lib/utils/dom'
import { isChunkLoadError } from 'lib/utils/isChunkLoadError'
import { compactNumber } from 'lib/utils/numbers'
import { objectsEqual } from 'lib/utils/objects'
import { retryImport } from 'lib/utils/retryImport'
import { sceneLogic } from 'scenes/sceneLogic'
import { Scene } from 'scenes/sceneTypes'
import { teamLogic } from 'scenes/teamLogic'
import { themeLogic } from '~/layout/navigation-3000/themeLogic'
import {
AnyResponseType,
ChartAxis,
ChartSettings,
ChartSettingsDisplay,
ChartSettingsFormatting,
DashboardFilter,
ConditionalFormattingRule,
VisualizationNode,
NodeKind,
HeatmapSettings,
HogQLVariable,
} from '~/queries/schema/schema-general'
import { QueryContext } from '~/queries/types'
import { ChartDisplayType, DashboardType } from '~/types'
import { captureBIWorksheetAction } from 'products/business_intelligence/frontend/biEditorAnalytics'
import { getBIResultDimensions } from 'products/business_intelligence/frontend/biEditorTypes'
import { getBIAutoChartType } from 'products/business_intelligence/frontend/biEditorTypes'
import { createBIMemberDisplayLookup } from 'products/business_intelligence/frontend/biMemberAliases'
import {
getBISeriesSettings,
getBIVisualizationResponse,
getBIVisualizationSource,
} from 'products/business_intelligence/frontend/biQueryResults'
import { isBIPivotTable } from 'products/business_intelligence/frontend/biTableLayout'
import type {
DataNode,
ErrorTrackingQueryResponse,
HogQLAutocompleteResponse,
HogQLMetadataResponse,
HogQLQueryResponse,
HogQueryResponse,
LogAttributesQueryResponse,
LogValuesQueryResponse,
MetricsQueryResponse,
RefreshType,
SessionsQueryResponse,
TraceSpansAggregationQueryResponse,
TraceSpansAttributeBreakdownQueryResponse,
TraceSpansQueryResponse,
} from '../../schema/schema-general'
import type { TraceSpansTreeQueryResponse } from '../../schema/schema-general'
import { DataNodeLogicProps, dataNodeLogic } from '../DataNode/dataNodeLogic'
import { QueryFeature, getQueryFeatures } from '../DataTable/queryFeatures'
import { getAutoBoxPlotSettings } from './Components/Charts/sqlBoxPlotAdapter'
import { humanizeEventColumnValue } from './eventColumnLabels'
import { ColumnScalar, FORMATTING_TEMPLATES } from './types'
export enum SideBarTab {
Series = 'series',
Display = 'display',
ConditionalFormatting = 'conditional_formatting',
}
export interface ColumnType {
name: ColumnScalar
isNumerical: boolean
}
export interface Column {
name: string
type: ColumnType
label: string
dataIndex: number
}
export interface TableRow {
rowIndex: number
}
export interface TableDataCell<T extends string | number | boolean | Date | null> {
value: T
formattedValue: string | object | null
type: ColumnScalar
sourceColumnName?: string
isTransposedHeader?: boolean
}
export interface AxisSeriesSettings {
formatting?: ChartSettingsFormatting
display?: ChartSettingsDisplay
}
export interface AxisSeries<T> {
column: Column
data: T[]
settings?: AxisSeriesSettings
}
export interface DataVisualizationLogicProps {
loadQueue?: DataNodeLogicProps['loadQueue']
key: string
query: VisualizationNode
editMode?: boolean
dataNodeCollectionId: string
setQuery?: (setter: (node: VisualizationNode) => VisualizationNode) => void
context?: QueryContext<VisualizationNode>
cachedResults?: AnyResponseType
insightLoading?: boolean
dashboardId?: DashboardType['id']
loadPriority?: number
retainResponseOnUnmount?: boolean
/** Dashboard variables to override the ones in the query */
variablesOverride?: Record<string, HogQLVariable> | null
filtersOverride?: DashboardFilter | null
limitContext?: 'posthog_ai'
}
export interface SelectedYAxis {
name: string
settings: AxisSeriesSettings
}
export const EmptyYAxisSeries: AxisSeries<number> = {
column: {
name: 'None',
type: {
name: 'INTEGER',
isNumerical: false,
},
label: 'None',
dataIndex: -1,
},
data: [],
}
const DefaultAxisSettings = (): AxisSeriesSettings => ({
formatting: {
prefix: '',
suffix: '',
},
})
/** Deep clone settings to prevent shared references between Y-axis entries */
const cloneSettings = (settings: AxisSeriesSettings): AxisSeriesSettings =>
mergeObject({}, settings) as AxisSeriesSettings
const cloneOrDefaultSettings = (settings?: AxisSeriesSettings): AxisSeriesSettings =>
settings ? cloneSettings(settings) : DefaultAxisSettings()
const TRANSPOSED_FIELD_COLUMN_NAME = '__transpose_field__'
const TRANSPOSED_ROW_COLUMN_PREFIX = '__transpose_row__'
export const formatDataWithSettings = (
data: number | string | null | object,
settings?: AxisSeriesSettings
): string | object | null => {
if (data === null || Number.isNaN(data)) {
return null
}
if (typeof data === 'object') {
return data
}
const decimalPlaces = settings?.formatting?.decimalPlaces
let dataAsString = `${data}`
if (typeof data === 'number') {
dataAsString = `${decimalPlaces != null ? data.toFixed(decimalPlaces) : data}`
if (settings?.formatting?.style === 'number') {
dataAsString = data.toLocaleString(undefined, {
minimumFractionDigits: decimalPlaces,
maximumFractionDigits: decimalPlaces,
})
}
if (settings?.formatting?.style === 'short') {
dataAsString = compactNumber(data)
}
if (settings?.formatting?.style === 'percent') {
dataAsString = `${data.toLocaleString(undefined, { minimumFractionDigits: decimalPlaces, maximumFractionDigits: decimalPlaces })}%`
}
}
if (settings?.formatting?.prefix) {
dataAsString = `${settings.formatting.prefix}${dataAsString}`
}
if (settings?.formatting?.suffix) {
dataAsString = `${dataAsString}${settings.formatting.suffix}`
}
return dataAsString
}
export const convertTableValue = (
value: string | number | null,
type: ColumnScalar
): string | number | boolean | null => {
if (value == null) {
return null
}
if (type === 'STRING') {
return value.toString()
}
if (type === 'INTEGER') {
if (typeof value === 'number') {
return value
}
return parseInt(value)
}
if (type === 'FLOAT' || type === 'DECIMAL') {
if (typeof value === 'number') {
return value
}
return parseFloat(value)
}
if (type === 'BOOLEAN') {
return Boolean(value)
}
if (type === 'DATE' || type === 'DATETIME') {
return dayjs(value).unix()
}
return value
}
const toFriendlyClickhouseTypeName = (type: string | undefined): ColumnScalar => {
if (!type) {
return 'UNKNOWN'
}
if (type.indexOf('Array') !== -1) {
return 'ARRAY'
}
if (type.indexOf('Tuple') !== -1) {
return 'TUPLE'
}
if (type.indexOf('Int') !== -1) {
return 'INTEGER'
}
if (type.indexOf('Float') !== -1) {
return 'FLOAT'
}
if (type.indexOf('DateTime') !== -1) {
return 'DATETIME'
}
if (type.indexOf('Date') !== -1) {
return 'DATE'
}
if (type.indexOf('Boolean') !== -1) {
return 'BOOLEAN'
}
if (type.indexOf('Decimal') !== -1) {
return 'DECIMAL'
}
if (type.indexOf('String') !== -1) {
return 'STRING'
}
return type as ColumnScalar
}
const isNumericalType = (type: ColumnScalar): boolean => {
if (type === 'INTEGER' || type === 'FLOAT' || type === 'DECIMAL') {
return true
}
return false
}
const columnsFromResponseFields = (columns: string[] = [], types: string[][] = []): Column[] => {
return columns.map((column, index) => {
const type = types[index]?.[1]
const friendlyClickhouseTypeName = toFriendlyClickhouseTypeName(type)
return {
name: column,
type: {
name: friendlyClickhouseTypeName,
isNumerical: isNumericalType(friendlyClickhouseTypeName),
},
label: `${column} - ${type}`,
dataIndex: index,
}
})
}
export const columnsFromResponse = (response: AnyResponseType | null): Column[] => {
if (!response) {
return []
}
return columnsFromResponseFields(
'columns' in response && Array.isArray(response.columns) ? response.columns : [],
'types' in response && Array.isArray(response.types) ? response.types : []
)
}
const deriveDefaultAxes = (columns: Column[]): { xAxis: string | null; yAxis: string[] } => {
const dateColumn = columns.find((column) => column.type.name.indexOf('DATE') !== -1)
const numericalColumns = columns.filter((column) => column.type.isNumerical)
const yAxis = numericalColumns.map((column) => column.name)
if (dateColumn) {
return { xAxis: dateColumn.name, yAxis }
}
const claimed = new Set(yAxis)
return { xAxis: columns.find((column) => !claimed.has(column.name))?.name ?? null, yAxis }
}
const resolveNonTimeSeriesVisualizationType = (columns: Column[]): ChartDisplayType => {
const stringColumns = columns.filter((column) => column.type.name === 'STRING')
const numericalColumns = columns.filter((column) => column.type.isNumerical)
if (stringColumns.length >= 2 && numericalColumns.length >= 1) {
return ChartDisplayType.TwoDimensionalHeatmap
}
if (numericalColumns.length === 1 && columns.length === 1) {
return ChartDisplayType.BoldNumber
}
if (numericalColumns.length > 0) {
return ChartDisplayType.ActionsBar
}
return ChartDisplayType.ActionsTable
}
export const rowCountFromResponse = (response: AnyResponseType | null): number => {
const rawResults =
response && 'results' in response ? response.results : response && 'result' in response ? response.result : []
return Array.isArray(rawResults) ? rawResults.length : 0
}
const hasTimeSeriesData = (columns: Column[], rowCount: number): boolean => {
const hasDateColumn = columns.some((column) => ['DATE', 'DATETIME'].includes(column.type.name))
const hasNumericColumn = columns.some((column) => column.type.isNumerical)
return hasDateColumn && hasNumericColumn && rowCount > 1
}
export const getAutoVisualizationType = (columns: Column[], rowCount: number): ChartDisplayType => {
if (hasTimeSeriesData(columns, rowCount)) {
return ChartDisplayType.ActionsLineGraph
}
return resolveNonTimeSeriesVisualizationType(columns)
}
const getHeatmapAutoSettings = (columns: Column[], heatmapSettings: HeatmapSettings): Partial<HeatmapSettings> => {
const stringColumns = columns.filter((column) => column.type.name === 'STRING')
const numericalColumns = columns.filter((column) => column.type.isNumerical)
const nextSettings: Partial<HeatmapSettings> = {}
if (!heatmapSettings.xAxisColumn && stringColumns[0]) {
nextSettings.xAxisColumn = stringColumns[0].name
}
if (!heatmapSettings.yAxisColumn && stringColumns[1]) {
nextSettings.yAxisColumn = stringColumns[1].name
}
if (!heatmapSettings.valueColumn && numericalColumns[0]) {
nextSettings.valueColumn = numericalColumns[0].name
}
return nextSettings
}
const applyAutoHeatmapSettings = (
actions: { updateChartSettings: (settings: ChartSettings) => void },
columns: Column[],
heatmapSettings: HeatmapSettings
): void => {
const autoSettings = getHeatmapAutoSettings(columns, heatmapSettings)
if (Object.keys(autoSettings).length === 0) {
return
}
actions.updateChartSettings({
heatmap: {
...heatmapSettings,
...autoSettings,
},
})
}
const mergeChartSettings = (state: ChartSettings, settings: ChartSettings): ChartSettings => {
return {
...state,
...settings,
heatmap:
state.heatmap || settings.heatmap
? {
...state.heatmap,
...settings.heatmap,
}
: undefined,
pie:
state.pie || settings.pie
? {
...state.pie,
...settings.pie,
}
: undefined,
scatter:
state.scatter || settings.scatter
? {
...state.scatter,
...settings.scatter,
}
: undefined,
boxPlot:
state.boxPlot || settings.boxPlot
? {
...state.boxPlot,
...settings.boxPlot,
}
: undefined,
metric:
state.metric || settings.metric
? {
...state.metric,
...settings.metric,
}
: undefined,
leftYAxisSettings:
state.leftYAxisSettings || settings.leftYAxisSettings
? {
...state.leftYAxisSettings,
...settings.leftYAxisSettings,
}
: undefined,
rightYAxisSettings:
state.rightYAxisSettings || settings.rightYAxisSettings
? {
...state.rightYAxisSettings,
...settings.rightYAxisSettings,
}
: undefined,
chartStyle:
state.chartStyle || settings.chartStyle
? {
...state.chartStyle,
...settings.chartStyle,
}
: undefined,
}
}
const shouldUseFirstNumericColumnAsContinuousChartXAxis = (
columns: Column[],
numericalColumns: Column[],
selectedXAxis: string | null,
selectedYAxis: (Pick<SelectedYAxis, 'name'> | null)[] | null
): boolean => {
if (selectedXAxis !== null || columns.length < 2 || numericalColumns.length < 2) {
return false
}
if (!columns.every((column) => column.type.isNumerical)) {
return false
}
if (!selectedYAxis || selectedYAxis.length !== numericalColumns.length) {
return false
}
const selectedYAxisNames = new Set(selectedYAxis.map((series) => series?.name))
return numericalColumns.every((column) => selectedYAxisNames.has(column.name))
}
const resolveScatterXAxisColumn = (
columns: Column[],
numericalColumns: Column[],
selectedXAxis: string | null,
selectedYAxis: (Pick<SelectedYAxis, 'name'> | null)[] | null
): Column | null => {
if (numericalColumns.length < 2) {
return null
}
const currentXAxis = columns.find((column) => column.name === selectedXAxis)
if (currentXAxis?.type.isNumerical) {
return currentXAxis
}
const selectedYAxisNames = new Set((selectedYAxis ?? []).map((series) => series?.name))
return numericalColumns.find((column) => !selectedYAxisNames.has(column.name)) ?? numericalColumns[0]
}
export function applyVisualizationType(
query: VisualizationNode,
visualizationType: ChartDisplayType,
columns: Column[],
rowCount: number
): VisualizationNode {
const numericalColumns = columns.filter((column) => column.type.isNumerical)
const chartSettings: ChartSettings = { ...query.chartSettings }
const columnNames = new Set(columns.map((column) => column.name))
const invalidX = chartSettings.xAxis !== undefined && !columnNames.has(chartSettings.xAxis.column)
const invalidY =
chartSettings.yAxis?.some(
(series) => !columns.find((column) => column.name === series.column)?.type.isNumerical
) ?? false
if (columns.length > 0 && (invalidX || invalidY)) {
chartSettings.xAxis = undefined
chartSettings.yAxis = undefined
}
// An empty yAxis records that the user deleted every series, so only absent axes are seeded.
if (chartSettings.xAxis === undefined && chartSettings.yAxis === undefined) {
const seeded = deriveDefaultAxes(columns)
if (seeded.yAxis.length > 0) {
chartSettings.yAxis = seeded.yAxis.map((column) => ({ column, settings: DefaultAxisSettings() }))
}
if (seeded.xAxis) {
chartSettings.xAxis = { column: seeded.xAxis }
}
}
const selectedXAxis = chartSettings.xAxis?.column ?? null
let yAxis = chartSettings.yAxis ? [...chartSettings.yAxis] : []
const selectedYAxis = yAxis.map((series) => ({ name: series.column }))
if (PIE_DISPLAY_TYPES.includes(visualizationType) && chartSettings.pie?.sliceContent === undefined) {
chartSettings.pie = { ...chartSettings.pie, sliceContent: 'labels' }
}
if (visualizationType === ChartDisplayType.ActionsDonut && chartSettings.pie?.showTotal === undefined) {
chartSettings.pie = { ...chartSettings.pie, showTotal: true }
}
if (visualizationType === ChartDisplayType.Metric) {
yAxis = yAxis.slice(0, 1)
}
// With several values a part-of-whole chart draws one part per column and ignores the x-axis, so a
// numeric column a line or scatter chart moved onto the x-axis goes back to the values. A series
// breakdown still needs the x-axis, so it stays then.
const numericXAxisColumn = numericalColumns.find((column) => column.name === selectedXAxis)
if (
PART_OF_WHOLE_DISPLAY_TYPES.includes(visualizationType) &&
!chartSettings.seriesBreakdownColumn &&
yAxis.length > 1 &&
numericXAxisColumn &&
!yAxis.some((series) => series.column === numericXAxisColumn.name)
) {
yAxis = [{ column: numericXAxisColumn.name, settings: DefaultAxisSettings() }, ...yAxis]
chartSettings.xAxis = undefined
}
if (
[ChartDisplayType.ActionsLineGraph, ChartDisplayType.ActionsAreaGraph].includes(visualizationType) &&
shouldUseFirstNumericColumnAsContinuousChartXAxis(columns, numericalColumns, selectedXAxis, selectedYAxis)
) {
const [xAxisColumn] = numericalColumns
chartSettings.xAxis = { column: xAxisColumn.name }
yAxis = yAxis.filter((series) => series.column !== xAxisColumn.name)
}
if (visualizationType === ChartDisplayType.ScatterPlot) {
const xAxisColumn = resolveScatterXAxisColumn(columns, numericalColumns, selectedXAxis, selectedYAxis)
if (xAxisColumn) {
chartSettings.xAxis = { column: xAxisColumn.name }
yAxis = yAxis.filter((series) => series.column !== xAxisColumn.name)
}
}
if (visualizationType === ChartDisplayType.BoxPlot) {
chartSettings.boxPlot = getAutoBoxPlotSettings(columns, chartSettings.boxPlot)
}
const isAutoHeatmap =
visualizationType === ChartDisplayType.Auto &&
getAutoVisualizationType(columns, rowCount) === ChartDisplayType.TwoDimensionalHeatmap
if (visualizationType === ChartDisplayType.TwoDimensionalHeatmap || isAutoHeatmap) {
const heatmap = chartSettings.heatmap ?? {}
const autoSettings = getHeatmapAutoSettings(columns, heatmap)
if (Object.keys(autoSettings).length > 0) {
chartSettings.heatmap = { ...heatmap, ...autoSettings }
}
}
if (chartSettings.yAxis !== undefined) {
chartSettings.yAxis = yAxis
}
return { ...query, display: visualizationType, chartSettings }
}
/**
* Establishes the scatter x-axis invariant: a numeric column on the x axis that isn't also a
* y-series. Runs from every entry path a scatter can arrive through, including column changes and
* persisted or assistant-created insights, so the chart never
* renders blank or plots a column against itself. A no-op when there's nothing to fix.
*/
const applyScatterXAxis = (
actions: {
updateXSeries: (columnName: string) => void
deleteYSeries: (seriesIndex: number) => void
},
columns: Column[],
selectedXAxis: string | null,
selectedYAxis: (SelectedYAxis | null)[] | null
): void => {
const numericalColumns = columns.filter((column) => column.type.isNumerical)
const xAxisColumn = resolveScatterXAxisColumn(columns, numericalColumns, selectedXAxis, selectedYAxis)
if (!xAxisColumn) {
return
}
if (xAxisColumn.name !== selectedXAxis) {
actions.updateXSeries(xAxisColumn.name)
}
// updateXSeries doesn't touch the y-series array, so this index stays valid.
const xAxisSeriesIndex = selectedYAxis?.findIndex((series) => series?.name === xAxisColumn.name) ?? -1
if (xAxisSeriesIndex > -1) {
actions.deleteYSeries(xAxisSeriesIndex)
}
}
// A named interface, because kea-typegen writes `typeof import('lib/hog')` as an absolute path.
interface HogVm {
execHog: typeof execHog
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataVisualizationLogicValues {
queryCancelled: boolean // dataNodeLogic
rawHasMoreData: boolean // dataNodeLogic
rawResponse:
| ErrorTrackingQueryResponse
| HogQLAutocompleteResponse
| HogQLMetadataResponse
| HogQLQueryResponse<any[]>
| HogQueryResponse
| LogAttributesQueryResponse
| LogValuesQueryResponse
| MetricsQueryResponse
| Record<string, any>
| SessionsQueryResponse
| TraceSpansAggregationQueryResponse
| TraceSpansAttributeBreakdownQueryResponse
| TraceSpansQueryResponse
| TraceSpansTreeQueryResponse
| null // dataNodeLogic
responseError: string | null // dataNodeLogic
responseLoading: boolean // dataNodeLogic
activeSceneId: string | null // sceneLogic
currentTeamId: number | null // teamLogic
isDarkModeOn: boolean // themeLogic
activeSideBarTab: SideBarTab
autoVisualizationType: ChartDisplayType
chartSettings: ChartSettings
columns: Column[]
conditionalFormattingRules: ConditionalFormattingRule[]
conditionalFormattingRulesPanelActiveKeys: string[]
dashboardId: any
dataVisualizationProps: DataVisualizationLogicProps
effectiveVisualizationType: ChartDisplayType
getSourceTableCell: (rowIndex: number, columnIndex: number) => TableDataCell<any>
getTableCell: (rowIndex: number, columnIndex: number) => TableDataCell<any>
hasDateTimeColumns: boolean
hasMoreData: boolean
hasSortedTable: boolean
hogVm: HogVm | null
hogVmLoadError: unknown
hogVmLoadFailed: boolean
isChartSettingsPanelOpen: boolean
isColumnPinned: (columnName: string) => boolean
isPinningEnabled: boolean
isShowingCachedResults: boolean
isTableVisualization: boolean
isTransposed: boolean
needsHogVm: boolean
numericalColumns: Column[]
pinnedColumns: string[]
presetChartHeight: boolean
query: VisualizationNode
response: AnyResponseType | null
selectedXAxis: string | null
selectedYAxis: (SelectedYAxis | null)[] | null
showEditingUI: boolean
showResultControls: boolean
showTableSettings: boolean
sourceFeatures: Set<QueryFeature>
sourceTabularColumns: AxisSeries<any>[]
tableResults: HogQLQueryResponse['results']
tableRows: TableRow[]
tabularColumnSettings: (SelectedYAxis | null)[] | null
tabularColumns: AxisSeries<any>[]
visualizationType: ChartDisplayType
xData: AxisSeries<string> | null
yData: AxisSeries<number | null>[]
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataVisualizationLogicActions {
loadData: (
refresh?: RefreshType | undefined,
alreadyRunningQueryId?: string | undefined,
overrideQuery?: DataNode<Record<string, any>> | undefined
) => {
overrideQuery: DataNode<Record<string, any>> | undefined
pollOnly: boolean
queryId: string
refresh: RefreshType | undefined
} // dataNodeLogic
_setQuery: (node: VisualizationNode) => {
node: VisualizationNode
}
addConditionalFormattingRule: (rule?: ConditionalFormattingRule) => {
isDarkModeOn: boolean
rule:
| ConditionalFormattingRule
| {
id: string
}
}
addYSeries: (
columnName?: string,
settings?: AxisSeriesSettings
) => {
allNumericalColumns: Column[]
columnName: string | undefined
settings: AxisSeriesSettings | undefined
}
clearAxis: () => {
value: true
}
deleteYSeries: (seriesIndex: number) => {
seriesIndex: number
}
initializeAxes: (
tabularColumns: SelectedYAxis[] | null,
yAxis: SelectedYAxis[] | null,
xAxis: string | null
) => {
tabularColumns: SelectedYAxis[] | null
xAxis: string | null
yAxis: SelectedYAxis[] | null
}
loadHogVm: () => {
value: true
}
setConditionalFormattingRulesPanelActiveKeys: (keys: string[]) => {
keys: string[]
}
setHogVm: (hogVm: HogVm) => {
hogVm: HogVm
}
setHogVmLoadError: (error: unknown) => {
error: unknown
}
setQuery: (setter: (node: VisualizationNode) => VisualizationNode) => {
setter: (node: VisualizationNode) => VisualizationNode
}
setSideBarTab: (tab: SideBarTab) => {
tab: SideBarTab
}
setTableSorted: () => {
value: true
}
setTransposeResults: (transpose: boolean) => {
transpose: boolean
}
setVisualizationType: (visualizationType: ChartDisplayType) => {
node: VisualizationNode
visualizationType: ChartDisplayType
}
toggleChartSettingsPanel: (open?: boolean) => {
open: boolean | undefined
}
toggleColumnPin: (columnName: string) => {
columnName: string
}
updateChartSettings: (settings: ChartSettings) => {
settings: ChartSettings
}
updateConditionalFormattingRule: (
rule: ConditionalFormattingRule,
deleteRule?: boolean
) => {
colorMode: string
deleteRule: boolean | undefined
rule: ConditionalFormattingRule
}
updateSeries: (
columnName: string,
settings?: AxisSeriesSettings
) => {
columnName: string
settings: AxisSeriesSettings | undefined
}
updateSeriesIndex: (
seriesIndex: number,
columnName: string,
settings?: AxisSeriesSettings
) => {
columnName: string
seriesIndex: number
settings: AxisSeriesSettings | undefined
}
updateXSeries: (columnName: string) => {
columnName: string
}
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataVisualizationLogicMeta {
key: string
sharedListeners: {
axesChanged: (
payload: any,
breakpoint: BreakPointFunction,
action: {
type: string
payload: any
},
previousState: any
) => void | Promise<void>
conditionalFormattingRules: (
payload: any,
breakpoint: BreakPointFunction,
action: {
type: string
payload: any
},
previousState: any
) => void | Promise<void>
pinnedColumnsChanged: (
payload: any,
breakpoint: BreakPointFunction,
action: {
type: string
payload: any
},
previousState: any
) => void | Promise<void>
}
__keaTypeGenInternalSelectorTypes: {
response: (
query: VisualizationNode,
rawResponse:
| ErrorTrackingQueryResponse
| HogQLAutocompleteResponse
| HogQLMetadataResponse
| HogQLQueryResponse<any[]>
| HogQueryResponse
| LogAttributesQueryResponse
| LogValuesQueryResponse
| MetricsQueryResponse
| Record<string, any>
| SessionsQueryResponse
| TraceSpansAggregationQueryResponse
| TraceSpansAttributeBreakdownQueryResponse
| TraceSpansQueryResponse
| TraceSpansTreeQueryResponse
| null
) => AnyResponseType | null
hasMoreData: (response: AnyResponseType | null, rawHasMoreData: boolean) => boolean
columns: (response: AnyResponseType | null) => Column[]
numericalColumns: (columns: Column[]) => Column[]
hasDateTimeColumns: (columns: Column[]) => boolean
dashboardId: (arg: any) => any
showEditingUI: (arg: boolean | undefined, dashboardId: any) => boolean
showResultControls: (arg: boolean | undefined, dashboardId: any) => boolean
presetChartHeight: (key: string, dashboardId: any, activeSceneId: string | null) => boolean
sourceFeatures: (query: VisualizationNode) => Set<QueryFeature>
isShowingCachedResults: (arg: any) => boolean
isTransposed: (query: VisualizationNode) => boolean
yData: (
selectedYAxis: (SelectedYAxis | null)[] | null,
response: AnyResponseType | null,
columns: Column[],
chartSettings: ChartSettings,
effectiveVisualizationType: ChartDisplayType,
query: VisualizationNode
) => AxisSeries<number | null>[]
xData: (
selectedXAxis: string | null,
response: AnyResponseType | null,
columns: Column[],
query: VisualizationNode
) => AxisSeries<string> | null
sourceTabularColumns: (
tabularColumnSettings: (SelectedYAxis | null)[] | null,
response: AnyResponseType | null,
columns: Column[]
) => AxisSeries<any>[]
tableResults: (response: AnyResponseType | null) => HogQLQueryResponse['results']
getSourceTableCell: (
sourceTabularColumns: AxisSeries<any>[],
tableResults: any[],
chartSettings: ChartSettings,
query: VisualizationNode
) => (rowIndex: number, columnIndex: number) => TableDataCell<any>
tabularColumns: (
sourceTabularColumns: AxisSeries<any>[],
tableResults: any[],
isTransposed: boolean
) => AxisSeries<any>[]
tableRows: (tableResults: any[], sourceTabularColumns: AxisSeries<any>[], isTransposed: boolean) => TableRow[]
getTableCell: (
getSourceTableCell: (rowIndex: number, columnIndex: number) => TableDataCell<any>,
sourceTabularColumns: AxisSeries<any>[],
isTransposed: boolean
) => (rowIndex: number, columnIndex: number) => TableDataCell<any>
dataVisualizationProps: (arg: any) => DataVisualizationLogicProps
effectiveVisualizationType: (
visualizationType: ChartDisplayType,
autoVisualizationType: ChartDisplayType
) => ChartDisplayType
autoVisualizationType: (
columns: Column[],
response: AnyResponseType | null,
query: VisualizationNode
) => ChartDisplayType
needsHogVm: (
visualizationType: ChartDisplayType,
effectiveVisualizationType: ChartDisplayType,
columns: Column[],
conditionalFormattingRules: ConditionalFormattingRule[],
query: VisualizationNode
) => boolean
hogVmLoadFailed: (needsHogVm: boolean, hogVmLoadError: unknown) => boolean
isTableVisualization: (effectiveVisualizationType: ChartDisplayType) => boolean
showTableSettings: (effectiveVisualizationType: ChartDisplayType) => boolean
isColumnPinned: (pinnedColumns: string[]) => (columnName: string) => boolean
isPinningEnabled: (activeSceneId: string | null, isTransposed: boolean) => boolean
}
}
export type dataVisualizationLogicType = MakeLogicType<
dataVisualizationLogicValues,
dataVisualizationLogicActions,
DataVisualizationLogicProps,
dataVisualizationLogicMeta
>
export const dataVisualizationLogic = kea<dataVisualizationLogicType>([
key((props) => props.key),
path(['queries', 'nodes', 'DataVisualization', 'dataVisualizationLogic']),
connect((props: DataVisualizationLogicProps) => ({
values: [
teamLogic,
['currentTeamId'],
dataNodeLogic({
loadQueue: props.loadQueue,
cachedResults: props.cachedResults,
key: props.key,
query: getBIVisualizationSource(props.query),
dataNodeCollectionId: props.dataNodeCollectionId,
loadPriority: props.loadPriority,
retainResponseOnUnmount: props.retainResponseOnUnmount,
variablesOverride: props.variablesOverride,
filtersOverride: props.filtersOverride,
limitContext: props.limitContext,
}),
[
'response as rawResponse',
'responseLoading',
'responseError',
'queryCancelled',
'hasMoreData as rawHasMoreData',
],
themeLogic,
['isDarkModeOn'],
sceneLogic,
['activeSceneId'],
],
actions: [
dataNodeLogic({
loadQueue: props.loadQueue,
cachedResults: props.cachedResults,
retainResponseOnUnmount: props.retainResponseOnUnmount,
key: props.key,
query: getBIVisualizationSource(props.query),
dataNodeCollectionId: props.dataNodeCollectionId,
loadPriority: props.loadPriority,
variablesOverride: props.variablesOverride,
filtersOverride: props.filtersOverride,
limitContext: props.limitContext,
}),
['loadData'],
],
})),
afterMount(({ actions, props }) => {
if (props.query) {
// populate fields like tabularColumnSettings, etc
actions._setQuery(props.query)
}
}),
propsChanged(({ actions, values, props }, oldProps) => {
// Without setQuery the internal query never equals props.query, so re-sync only when the prop changes.
if (!props.setQuery && objectsEqual(props.query, oldProps.query)) {
return
}
if (props.query && !objectsEqual(props.query, values.query)) {
actions._setQuery(props.query)
}
}),
props({ query: { source: {} } } as DataVisualizationLogicProps),
actions(({ values }) => ({
loadHogVm: true,
setHogVm: (hogVm: HogVm) => ({ hogVm }),
setHogVmLoadError: (error: unknown) => ({ error }),
setVisualizationType: (visualizationType: ChartDisplayType) => ({
visualizationType,
node: applyVisualizationType(
values.query,
visualizationType,
values.columns,
rowCountFromResponse(values.response)
),
}),
updateXSeries: (columnName: string) => ({
columnName,
}),
updateSeriesIndex: (seriesIndex: number, columnName: string, settings?: AxisSeriesSettings) => ({
seriesIndex,
columnName,
settings,
}),
updateSeries: (columnName: string, settings?: AxisSeriesSettings) => ({ columnName, settings }),
addYSeries: (columnName?: string, settings?: AxisSeriesSettings) => ({
columnName,
settings,
allNumericalColumns: values.numericalColumns,
}),
deleteYSeries: (seriesIndex: number) => ({ seriesIndex }),
initializeAxes: (
tabularColumns: SelectedYAxis[] | null,
yAxis: SelectedYAxis[] | null,
xAxis: string | null
) => ({ tabularColumns, yAxis, xAxis }),
clearAxis: true,
setQuery: (setter: (node: VisualizationNode) => VisualizationNode) => ({ setter }),
updateChartSettings: (settings: ChartSettings) => ({ settings }),
setSideBarTab: (tab: SideBarTab) => ({ tab }),
toggleChartSettingsPanel: (open?: boolean) => ({ open }),
addConditionalFormattingRule: (rule?: ConditionalFormattingRule) => ({
rule: rule ?? { id: uuid() },
isDarkModeOn: values.isDarkModeOn,
}),
updateConditionalFormattingRule: (rule: ConditionalFormattingRule, deleteRule?: boolean) => ({
rule,
deleteRule,
colorMode: values.isDarkModeOn ? 'dark' : 'light',
}),
setConditionalFormattingRulesPanelActiveKeys: (keys: string[]) => ({ keys }),
toggleColumnPin: (columnName: string) => ({ columnName }),
setTableSorted: true,
setTransposeResults: (transpose: boolean) => ({ transpose }),
_setQuery: (node: VisualizationNode) => ({ node }),
})),
reducers(({ props }) => ({
hogVm: [null as HogVm | null, { setHogVm: (_, { hogVm }) => hogVm }],
hogVmLoadError: [null as unknown, { setHogVmLoadError: (_, { error }) => error, setHogVm: () => null }],
query: [
props.query,
{
setQuery: (state, { setter }) => setter(state),
setVisualizationType: (_, { node }) => node,
_setQuery: (_, { node }) => node,
},
],
visualizationType: [
props.query.display ?? ChartDisplayType.ActionsTable,
{
setVisualizationType: (_, { visualizationType }) => visualizationType,
_setQuery: (_, { node }) => node.display ?? ChartDisplayType.ActionsTable,
},
],
tabularColumnSettings: [
null as (SelectedYAxis | null)[] | null,
{
_setQuery: (state, { node }) => {
if (node.tableSettings?.columns) {
return node.tableSettings.columns.map((column) => ({
name: column.column,
settings: cloneOrDefaultSettings(column.settings),
}))
}
return state
},
clearAxis: () => null,
initializeAxes: (state, { tabularColumns }) => tabularColumns ?? state,
updateSeries: (state, { columnName, settings }) => {
if (!state) {
return null
}
const ySeries = [...state]
const index = ySeries.findIndex((n) => n?.name === columnName)
if (index < 0) {
return ySeries
}
ySeries[index] = {
name: columnName,
settings: mergeObject({}, ySeries[index]?.settings ?? {}, settings),
}
return ySeries
},
updateSeriesIndex: (state, { seriesIndex, columnName, settings }) => {
if (!state) {
return null
}
const ySeries = [...state]
ySeries[seriesIndex] = {
name: columnName,
settings: mergeObject({}, ySeries[seriesIndex]?.settings ?? {}, settings),
}
return ySeries
},
},
],
selectedXAxis: [
props.query.chartSettings?.xAxis?.column ?? null,
{
setVisualizationType: (_, { node }) => node.chartSettings?.xAxis?.column ?? null,
_setQuery: (_, { node }) => node.chartSettings?.xAxis?.column ?? null,
clearAxis: () => null,
updateXSeries: (_, { columnName }) => columnName,
initializeAxes: (state, { xAxis }) => xAxis ?? state,
},
],
selectedYAxis: [
(props.query.chartSettings?.yAxis?.map((axis) => ({
name: axis.column,
settings: cloneOrDefaultSettings(axis.settings),
})) ?? null) as (SelectedYAxis | null)[] | null,
{
setVisualizationType: (state, { node }) => {
if (node.chartSettings?.yAxis) {
return node.chartSettings.yAxis.map((axis) => ({
name: axis.column,
settings: cloneOrDefaultSettings(axis.settings),
}))
}
return state
},
_setQuery: (state, { node }) => {
if (node.chartSettings?.yAxis) {
return node.chartSettings.yAxis.map((axis) => ({
name: axis.column,
settings: cloneOrDefaultSettings(axis.settings),
}))
}
return state
},
clearAxis: () => null,
initializeAxes: (state, { yAxis }) => yAxis ?? state,
addYSeries: (state, { columnName, settings, allNumericalColumns }) => {
if (!state && columnName !== undefined) {
return [{ name: columnName, settings: settings ?? DefaultAxisSettings() }]
}
if (!state) {
return [null]
}
if (!columnName) {
const ungraphedColumns = allNumericalColumns.filter(
(n) => !state.map((m) => m?.name).includes(n.name)
)
if (ungraphedColumns.length > 0) {
return [
...state,
{ name: ungraphedColumns[0].name, settings: settings ?? DefaultAxisSettings() },
]
}
}
return [
...state,
columnName === undefined
? null
: { name: columnName, settings: settings ?? DefaultAxisSettings() },
]
},
updateSeriesIndex: (state, { seriesIndex, columnName, settings }) => {
if (!state) {
return null
}
const ySeries = [...state]
ySeries[seriesIndex] = {
name: columnName,
settings: mergeObject({}, ySeries[seriesIndex]?.settings ?? {}, settings),
}
return ySeries
},
updateSeries: (state, { columnName, settings }) => {
if (!state) {
return null
}
const ySeries = [...state]
const index = ySeries.findIndex((n) => n?.name === columnName)
if (index < 0) {
return ySeries
}
ySeries[index] = {
name: columnName,
settings: mergeObject({}, ySeries[index]?.settings ?? {}, settings),
}
return ySeries
},
deleteYSeries: (state, { seriesIndex }) => {
if (!state) {
return null
}
if (state.length <= 1) {
return [null]
}
const ySeries = [...state]
ySeries.splice(seriesIndex, 1)
return ySeries
},
},
],
activeSideBarTab: [
SideBarTab.Series as SideBarTab,
{
setSideBarTab: (_state, { tab }) => tab,
},
],
chartSettings: [
props.query.chartSettings ?? ({} as ChartSettings),
{
setVisualizationType: (state, { node }) => node.chartSettings ?? state,
_setQuery: (state, { node }) => node.chartSettings ?? state,
updateChartSettings: (state, { settings }) => {
return mergeChartSettings(state, settings)
},
},
],
isChartSettingsPanelOpen: [
false as boolean,
{
toggleChartSettingsPanel: (state, { open }) => {
if (open === undefined) {
return !state
}
return open
},
setVisualizationType: (state, { visualizationType }) => {
if (state) {
return true
}
return visualizationType !== ChartDisplayType.ActionsTable
},
},
],
conditionalFormattingRules: [
[] as ConditionalFormattingRule[],
{
_setQuery: (state, { node }) => {
if (node.tableSettings?.conditionalFormatting) {
return node.tableSettings.conditionalFormatting
}
return state
},
addConditionalFormattingRule: (state, { rule, isDarkModeOn }) => {
const rules = [...state]
rules.push({
templateId: FORMATTING_TEMPLATES[0].id,
columnName: '',
bytecode: [],
input: '',
color: isDarkModeOn ? RGBToHex(lightenDarkenColor('#FFADAD', -30)) : '#FFADAD',
...rule,
})
return rules
},
updateConditionalFormattingRule: (state, { rule, deleteRule, colorMode }) => {
const rules = [...state]
const index = rules.findIndex((n) => n.id === rule.id)
if (index === -1) {
return rules
}
if (deleteRule) {
rules.splice(index, 1)
return rules
}
rules[index] = { ...rule, colorMode: colorMode as 'light' | 'dark' }
return rules
},
},
],
conditionalFormattingRulesPanelActiveKeys: [
[] as string[],
{
_setQuery: (state, { node }) => {
if (node.tableSettings?.conditionalFormatting) {
return node.tableSettings.conditionalFormatting.map((n) => n.id)
}
return state
},
addConditionalFormattingRule: (state, { rule: { id } }) => {
return [...state, id]
},
setConditionalFormattingRulesPanelActiveKeys: (_, { keys }) => {
return [...keys]
},
},
],
pinnedColumns: [
[] as string[],
{
persist: true,
// strips the dashboard suffix from the key so pinned columns persist across
// dashboard and insight views
storageKey: `data-visualization-pinned-columns-${props.key.split('/on-dashboard-')[0]}`,
},
{
_setQuery: (state, { node }) => {
return node.tableSettings?.pinnedColumns ?? state
},
toggleColumnPin: (state, { columnName }) => {
if (state.includes(columnName)) {
return state.filter((k: string) => k !== columnName)
}
return [...state, columnName]
},
},
],
hasSortedTable: [
false,
{
setTableSorted: () => true,
},
],
})),
selectors({
response: [
(s) => [s.query, s.rawResponse],
(query: VisualizationNode, response: AnyResponseType | null): AnyResponseType | null =>
getBIVisualizationResponse(query, response),
],
hasMoreData: [
(s) => [s.response, s.rawHasMoreData],
(response: AnyResponseType | null, rawHasMoreData: boolean): boolean =>
!!(response && 'hasMore' in response && response.hasMore) || rawHasMoreData,
],
columns: [
(s) => [s.response],
(
response:
| Record<string, any>
| null
| import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
| import('~/queries/schema/schema-general').HogQLAutocompleteResponse
| import('~/queries/schema/schema-general').HogQLMetadataResponse
| import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
| import('~/queries/schema/schema-general').HogQueryResponse
| import('~/queries/schema/schema-general').LogAttributesQueryResponse
| import('~/queries/schema/schema-general').LogValuesQueryResponse
| import('~/queries/schema/schema-general').MetricsQueryResponse
| import('~/queries/schema/schema-general').SessionsQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
| import('~/queries/schema/schema-general').TraceSpansQueryResponse
): Column[] => columnsFromResponse(response),
{ resultEqualityCheck: objectsEqual },
],
numericalColumns: [
(s) => [s.columns],
(columns: Column[]): Column[] => {
return columns.filter((n) => n.type.isNumerical)
},
],
hasDateTimeColumns: [
(s) => [s.columns],
(columns: Column[]): boolean => columns.some((column) => ['DATE', 'DATETIME'].includes(column.type.name)),
],
dashboardId: [() => [(_, props) => props.dashboardId], (dashboardId) => dashboardId ?? null],
showEditingUI: [
(s) => [(_, props: DataVisualizationLogicProps) => props.editMode, s.dashboardId],
(editMode: boolean | undefined, dashboardId) => {
if (dashboardId) {
return false
}
return !!editMode
},
],
showResultControls: [
(s) => [(_, props: DataVisualizationLogicProps) => props.editMode, s.dashboardId],
(editMode: boolean | undefined, dashboardId) => {
if (editMode) {
return true
}
return !dashboardId
},
],
presetChartHeight: [
(s, props) => [props.key, s.dashboardId, s.activeSceneId],
(key: string, dashboardId, activeSceneId: string | null) => {
// Keys for SQL editor visualizations can render outside the SQLEditor scene,
// e.g. in embedded mode, so key matching keeps sizing consistent.
const editorVisualization =
activeSceneId === Scene.BusinessIntelligence ||
activeSceneId === Scene.SQLEditor ||
key.includes('SQLEditor') ||
key.startsWith('data-warehouse-editor-data-node-')
if (activeSceneId === Scene.Insight) {
return true
}
return !key.includes('new-SQL') && !dashboardId && !editorVisualization
},
],
sourceFeatures: [
(_, props) => [props.query],
(query: VisualizationNode): Set<QueryFeature> => getQueryFeatures(query.source),
],
isShowingCachedResults: [
() => [(_, props) => props.cachedResults ?? null],
(cachedResults: AnyResponseType | null): boolean => !!cachedResults,
],
isTransposed: [
(s) => [s.query],
(query: VisualizationNode): boolean => query.tableSettings?.transpose ?? false,
],
yData: [
(s) => [s.selectedYAxis, s.response, s.columns, s.chartSettings, s.effectiveVisualizationType, s.query],
(
ySeries: (SelectedYAxis | null)[] | null,
response:
| Record<string, any>
| null
| import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
| import('~/queries/schema/schema-general').HogQLAutocompleteResponse
| import('~/queries/schema/schema-general').HogQLMetadataResponse
| import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
| import('~/queries/schema/schema-general').HogQueryResponse
| import('~/queries/schema/schema-general').LogAttributesQueryResponse
| import('~/queries/schema/schema-general').LogValuesQueryResponse
| import('~/queries/schema/schema-general').MetricsQueryResponse
| import('~/queries/schema/schema-general').SessionsQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
| import('~/queries/schema/schema-general').TraceSpansQueryResponse,
columns: Column[],
chartSettings: ChartSettings,
visualizationType: ChartDisplayType,
query: VisualizationNode
): AxisSeries<number | null>[] => {
if (!response || ySeries === null || ySeries.length === 0) {
return [EmptyYAxisSeries]
}
const showNullsAsZero = chartSettings.showNullsAsZero ?? false
const data =
'results' in response && Array.isArray(response.results)
? response.results
: 'result' in response && Array.isArray(response.result)
? response.result
: []
const seriesRows = visualizationType === ChartDisplayType.ActionsTable ? [] : data
const mappedSeries = visualizationType === ChartDisplayType.Metric ? ySeries.slice(0, 1) : ySeries
const seriesData = mappedSeries
.map((series): AxisSeries<number | null> | null => {
if (!series) {
return EmptyYAxisSeries
}
const column = columns.find((n) => n.name === series.name)
if (!column) {
return EmptyYAxisSeries
}
return {
column,
data: seriesRows.map((n) => {
try {
const multiplier = series.settings.formatting?.style === 'percent' ? 100 : 1
const isNotANumber =
Number.isNaN(n[column.dataIndex]) ||
n[column.dataIndex] === undefined ||
n[column.dataIndex] === null
if (isNotANumber) {
return showNullsAsZero ? 0 : null
}
// Do not round to decimalPlaces here. The chart formatters round for display,
// and the metric card and pie totals must sum the raw values.
const isInt = Number.isInteger(n[column.dataIndex])
const parsed = isInt
? parseInt(n[column.dataIndex], 10) * multiplier
: parseFloat(n[column.dataIndex]) * multiplier
return Number.isNaN(parsed) ? (showNullsAsZero ? 0 : null) : parsed
} catch {
return showNullsAsZero ? 0 : null
}
}),
settings: getBISeriesSettings(query, series.settings),
}
})
.filter((series): series is AxisSeries<number | null> => Boolean(series))
return seriesData
},
],
xData: [
(s) => [s.selectedXAxis, s.response, s.columns, s.query],
(
xSeries: string | null,
response:
| Record<string, any>
| null
| import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
| import('~/queries/schema/schema-general').HogQLAutocompleteResponse
| import('~/queries/schema/schema-general').HogQLMetadataResponse
| import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
| import('~/queries/schema/schema-general').HogQueryResponse
| import('~/queries/schema/schema-general').LogAttributesQueryResponse
| import('~/queries/schema/schema-general').LogValuesQueryResponse
| import('~/queries/schema/schema-general').MetricsQueryResponse
| import('~/queries/schema/schema-general').SessionsQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
| import('~/queries/schema/schema-general').TraceSpansQueryResponse,
columns: Column[],
query: VisualizationNode
): AxisSeries<string> | null => {
if (!response) {
return {
column: {
name: 'None',
type: {
name: 'STRING',
isNumerical: false,
},
label: 'None',
dataIndex: -1,
},
data: [],
}
}
const data =
('results' in response ? response.results : 'result' in response ? response.result : null) ?? []
if (xSeries === null) {
return {
column: {
name: 'None',
type: {
name: 'STRING',
isNumerical: false,
},
label: 'None',
dataIndex: -1,
},
data: data.map(() => ''),
}
}
const column = columns.find((n) => n.name === xSeries)
if (!column) {
return null
}
return {
column,
data: data.map((n: any) =>
query.kind === NodeKind.BIVisualizationNode
? n[column.dataIndex]
: humanizeEventColumnValue(column.name, n[column.dataIndex])
),
}
},
],
sourceTabularColumns: [
(s) => [s.tabularColumnSettings, s.response, s.columns],
(
tabularColumnSettings: (SelectedYAxis | null)[] | null,
response:
| Record<string, any>
| null
| import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
| import('~/queries/schema/schema-general').HogQLAutocompleteResponse
| import('~/queries/schema/schema-general').HogQLMetadataResponse
| import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
| import('~/queries/schema/schema-general').HogQueryResponse
| import('~/queries/schema/schema-general').LogAttributesQueryResponse
| import('~/queries/schema/schema-general').LogValuesQueryResponse
| import('~/queries/schema/schema-general').MetricsQueryResponse
| import('~/queries/schema/schema-general').SessionsQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
| import('~/queries/schema/schema-general').TraceSpansQueryResponse,
columns: Column[]
): AxisSeries<any>[] => {
if (!response) {
return []
}
return columns.map((col) => {
const series = (tabularColumnSettings || []).find((n) => n?.name === col.name)
return {
column: col,
data: [],
settings: series?.settings ?? DefaultAxisSettings(),
}
})
},
],
tableResults: [
(s) => [s.response],
(response: AnyResponseType | null): HogQLQueryResponse['results'] => {
if (response && 'results' in response && Array.isArray(response.results)) {
return response.results
}
if (response && 'result' in response && Array.isArray(response.result)) {
return response.result
}
return []
},
],
getSourceTableCell: [
(s) => [s.sourceTabularColumns, s.tableResults, s.chartSettings, s.query],
(
sourceTabularColumns: AxisSeries<any>[],
data: HogQLQueryResponse['results'],
chartSettings: ChartSettings,
query: VisualizationNode
): ((rowIndex: number, columnIndex: number) => TableDataCell<any>) => {
const showNullsAsZero = chartSettings.showNullsAsZero ?? false
const dimensions = new Map(
query.kind === NodeKind.BIVisualizationNode
? getBIResultDimensions(query.config).map(({ column, field }) => [column, field])
: []
)
const memberDisplay =
query.kind === NodeKind.BIVisualizationNode ? createBIMemberDisplayLookup(query.config) : undefined
return (rowIndex, columnIndex): TableDataCell<any> => {
const column = sourceTabularColumns[columnIndex]
if (!column) {
return {
value: null,
formattedValue: null,
type: 'STRING',
}
}
const value = data[rowIndex][column.column.dataIndex]
const dimension = dimensions.get(column.column.name)
const alias = dimension ? memberDisplay?.(dimension, value) : undefined
if (alias !== undefined) {
return { value, formattedValue: alias, type: column.column.type.name }
}
if (column.column.type.isNumerical) {
try {
if (value === null) {
const nullReplacement = showNullsAsZero ? 0 : null
return {
value: nullReplacement,
formattedValue: formatDataWithSettings(nullReplacement, column.settings),
type: column.column.type.name,
}
}
const multiplier = column.settings?.formatting?.style === 'percent' ? 100 : 1
if (
column.settings?.formatting?.decimalPlaces != null &&
column.settings.formatting.style !== 'short'
) {
return {
value,
formattedValue: formatDataWithSettings(
parseFloat(
(parseFloat(value.toString()) * multiplier).toFixed(
column.settings.formatting.decimalPlaces
)
),
column.settings
),
type: column.column.type.name,
}
}
const isInt = Number.isInteger(value)
return {
value,
formattedValue: formatDataWithSettings(
isInt
? parseInt(value.toString(), 10) * multiplier
: parseFloat(value.toString()) * multiplier,
column.settings
),
type: column.column.type.name,
}
} catch {
return {
value: 0,
formattedValue: '0',
type: column.column.type.name,
}
}
}
return {
value: convertTableValue(value, column.column.type.name),
formattedValue: formatDataWithSettings(value, column.settings),
type: column.column.type.name,
}
}
},
],
tabularColumns: [
(s) => [s.sourceTabularColumns, s.tableResults, s.isTransposed],
(
sourceTabularColumns: AxisSeries<any>[],
tableResults: HogQLQueryResponse['results'],
isTransposed: boolean
): AxisSeries<any>[] => {
if (!isTransposed) {
return sourceTabularColumns
}
if (sourceTabularColumns.length === 0) {
return []
}
return [
{
column: {
name: TRANSPOSED_FIELD_COLUMN_NAME,
type: {
name: 'STRING',
isNumerical: false,
},
label: 'Field',
dataIndex: -1,
},
data: [],
settings: {
...DefaultAxisSettings(),
display: {
label: 'Field',
},
},
},
...Array.from(
{ length: tableResults.length },
(_, index): AxisSeries<any> => ({
column: {
name: `${TRANSPOSED_ROW_COLUMN_PREFIX}${index}`,
type: {
name: 'STRING',
isNumerical: false,
},
label: `Row ${index + 1}`,
dataIndex: -1,
},
data: [],
settings: {
...DefaultAxisSettings(),
display: {
label: `Row ${index + 1}`,
},
},
})
),
]
},
],
tableRows: [
(s) => [s.tableResults, s.sourceTabularColumns, s.isTransposed],
(results: HogQLQueryResponse['results'], columns: AxisSeries<any>[], isTransposed: boolean): TableRow[] => {
if (results.length === 0) {
return []
}
return Array.from({ length: isTransposed ? columns.length : results.length }, (_, rowIndex) => ({
rowIndex,
}))
},
],
getTableCell: [
(s) => [s.getSourceTableCell, s.sourceTabularColumns, s.isTransposed],
(
getSourceTableCell: (rowIndex: number, columnIndex: number) => TableDataCell<any>,
columns: AxisSeries<any>[],
isTransposed: boolean
): ((rowIndex: number, columnIndex: number) => TableDataCell<any>) =>
(rowIndex, columnIndex): TableDataCell<any> => {
if (!isTransposed) {
return getSourceTableCell(rowIndex, columnIndex)
}
const sourceColumnName = columns[rowIndex].column.name
if (columnIndex === 0) {
return {
value: sourceColumnName,
formattedValue: null,
type: 'STRING',
sourceColumnName,
isTransposedHeader: true,
}
}
return { ...getSourceTableCell(columnIndex - 1, rowIndex), sourceColumnName }
},
],
dataVisualizationProps: [() => [(_, props) => props], (props): DataVisualizationLogicProps => props],
effectiveVisualizationType: [
(s) => [s.visualizationType, s.autoVisualizationType],
(visualizationType: ChartDisplayType, autoVisualizationType: ChartDisplayType): ChartDisplayType =>
visualizationType === ChartDisplayType.Auto ? autoVisualizationType : visualizationType,
],
autoVisualizationType: [
(s) => [s.columns, s.response, s.query],
(
columns: Column[],
response:
| Record<string, any>
| null
| import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
| import('~/queries/schema/schema-general').HogQLAutocompleteResponse
| import('~/queries/schema/schema-general').HogQLMetadataResponse
| import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
| import('~/queries/schema/schema-general').HogQueryResponse
| import('~/queries/schema/schema-general').LogAttributesQueryResponse
| import('~/queries/schema/schema-general').LogValuesQueryResponse
| import('~/queries/schema/schema-general').MetricsQueryResponse
| import('~/queries/schema/schema-general').SessionsQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
| import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
| import('~/queries/schema/schema-general').TraceSpansQueryResponse,
query: VisualizationNode
): ChartDisplayType =>
query.kind === NodeKind.BIVisualizationNode
? getBIAutoChartType(query.config)
: getAutoVisualizationType(columns, rowCountFromResponse(response)),
],
// The Hog VM and its crypto polyfills are large, so only a table that shows formatting rules loads them.
// Auto resolves to a table until columns arrive, so it waits for them before it decides.
needsHogVm: [
(s) => [
s.visualizationType,
s.effectiveVisualizationType,
s.columns,
s.conditionalFormattingRules,
s.query,
],
(
visualizationType: ChartDisplayType,
effectiveVisualizationType: ChartDisplayType,
columns: Column[],
rules: ConditionalFormattingRule[],
query: VisualizationNode
): boolean =>
(visualizationType !== ChartDisplayType.Auto || columns.length > 0) &&
(effectiveVisualizationType === ChartDisplayType.ActionsTable ||
(query.kind === NodeKind.BIVisualizationNode && isBIPivotTable(query.config))) &&
rules.length > 0,
],
hogVmLoadFailed: [
(s) => [s.needsHogVm, s.hogVmLoadError],
(needsHogVm: boolean, hogVmLoadError: unknown): boolean => needsHogVm && !!hogVmLoadError,
],
isTableVisualization: [
(s) => [s.effectiveVisualizationType],
(visualizationType: ChartDisplayType): boolean =>
// BoldNumber relies on yAxis formatting so it's considered a table visualization
visualizationType === ChartDisplayType.ActionsTable ||
visualizationType === ChartDisplayType.BoldNumber,
],
showTableSettings: [
(s) => [s.effectiveVisualizationType],
(visualizationType: ChartDisplayType): boolean =>
visualizationType === ChartDisplayType.ActionsTable ||
visualizationType === ChartDisplayType.BoldNumber,
],
isColumnPinned: [
(s) => [s.pinnedColumns],
(pinnedColumns: string[]) =>
(columnName: string): boolean => {
return pinnedColumns.includes(columnName)
},
],
isPinningEnabled: [
(s) => [s.activeSceneId, s.isTransposed],
(activeSceneId: Scene | null, isTransposed: boolean): boolean => {
// disable column pinning in sql editor or when transposed
return activeSceneId !== Scene.SQLEditor && !isTransposed
},
],
}),
sharedListeners(({ values, actions }) => ({
axesChanged: () => {
const yColumns =
values.selectedYAxis?.filter((n: SelectedYAxis | null): n is SelectedYAxis => Boolean(n)) ?? []
const xColumn: ChartAxis | undefined =
values.selectedXAxis !== null ? { column: values.selectedXAxis } : undefined
const columns =
values.tabularColumnSettings?.filter((n: SelectedYAxis | null): n is SelectedYAxis => Boolean(n)) ?? []
actions.setQuery((query) => ({
...query,
chartSettings: {
...query.chartSettings,
yAxis: yColumns.map((n) => ({ column: n.name, settings: cloneSettings(n.settings) })),
xAxis: xColumn,
},
tableSettings: {
...query.tableSettings,
columns: columns.map((n) => ({ column: n.name, settings: cloneSettings(n.settings) })),
},
}))
},
conditionalFormattingRules: () => {
const rules = values.conditionalFormattingRules
const saveableRules = rules.filter((n) => n.columnName && n.input && n.templateId && n.bytecode.length)
if (values.query.kind === NodeKind.BIVisualizationNode) {
captureBIWorksheetAction('conditional_formatting_updated', values.query.config, {
rule_count: saveableRules.length,
})
}
actions.setQuery((query) => ({
...query,
tableSettings: {
...query.tableSettings,
conditionalFormatting: saveableRules,
},
}))
},
pinnedColumnsChanged: () => {
actions.setQuery((query) => ({
...query,
tableSettings: {
...query.tableSettings,
pinnedColumns: values.pinnedColumns,
},
}))
},
})),
listeners(({ props, values, actions, sharedListeners }) => ({
setSideBarTab: ({ tab }) => {
if (tab === SideBarTab.ConditionalFormatting && values.query.kind === NodeKind.BIVisualizationNode) {
captureBIWorksheetAction('conditional_formatting_opened', values.query.config)
}
},
loadHogVm: async () => {
try {
actions.setHogVm(await retryImport(() => import('lib/hog')))
} catch (error) {
// A chunk that fails to load is a network or stale-deploy problem, not a bug to report.
if (!isChunkLoadError(error)) {
posthog.captureException(error)
}
actions.setHogVmLoadError(error)
}
},
updateChartSettings: ({ settings }) => {
if (values.query.kind === NodeKind.BIVisualizationNode) {
captureBIWorksheetAction('chart_settings_changed', values.query.config, {
setting_keys: Object.keys(settings),
})
}
actions.setQuery((query) => ({
...query,
chartSettings: mergeChartSettings(query.chartSettings ?? ({} as ChartSettings), settings),
}))
},
setQuery: ({ setter }) => {
if (props.setQuery) {
props.setQuery(setter)
}
},
setVisualizationType: ({ node }) => {
props.setQuery?.(() => node)
},
setTransposeResults: ({ transpose }) => {
posthog.capture('sql table transposed', { transpose, query_kind: values.query.kind })
actions.setQuery((query) => ({
...query,
tableSettings: {
...query.tableSettings,
transpose,
},
}))
},
toggleChartSettingsPanel: ({ open }) => {
const shouldOpen = open ?? !values.isChartSettingsPanelOpen
if (!shouldOpen) {
return
}
if (values.visualizationType !== ChartDisplayType.TwoDimensionalHeatmap) {
return
}
applyAutoHeatmapSettings(actions, values.columns, values.chartSettings.heatmap ?? {})
},
// Plain tables do not mount seriesBreakdownLogic, so the breakdown resets here.
clearAxis: [
() =>
actions.setQuery((query) => ({
...query,
chartSettings: { ...query.chartSettings, seriesBreakdownColumn: undefined },
})),
sharedListeners.axesChanged,
],
updateXSeries: [sharedListeners.axesChanged],
addYSeries: [sharedListeners.axesChanged],
initializeAxes: [sharedListeners.axesChanged],
updateSeriesIndex: [sharedListeners.axesChanged],
updateSeries: [sharedListeners.axesChanged],
deleteYSeries: [sharedListeners.axesChanged],
updateConditionalFormattingRule: [sharedListeners.conditionalFormattingRules],
toggleColumnPin: [
({ columnName }) => {
posthog.capture('sql table column pin toggled', {
pinned: values.isColumnPinned(columnName),
query_kind: values.query.kind,
})
},
sharedListeners.pinnedColumnsChanged,
],
})),
subscriptions(({ actions, values }) => ({
needsHogVm: (needsHogVm: boolean) => {
if (needsHogVm && !values.hogVm) {
actions.loadHogVm()
}
},
columns: (value: Column[], oldValue: Column[]) => {
// If the response is cleared, then don't update any internal values
if (!values.response || (!(values.response as any).results && !(values.response as any).result)) {
return
}
// When query columns update, clear all internal values and re-setup tabular columns and chart series
const oldTabularColumnSettings: (SelectedYAxis | null)[] | null = JSON.parse(
JSON.stringify(values.tabularColumnSettings)
)
const currentColumnNames = new Set(value.map((column) => column.name))
const hasInvalidSelectedXAxis =
values.selectedXAxis !== null && !currentColumnNames.has(values.selectedXAxis)
const hasInvalidSelectedYAxis =
values.selectedYAxis?.some((series) => {
if (series === null) {
return false
}
const column = value.find((nextColumn) => nextColumn.name === series.name)
return !column || !column.type.isNumerical
}) ?? false
if (hasInvalidSelectedXAxis || hasInvalidSelectedYAxis) {
actions.clearAxis()
} else if (oldValue && oldValue.length) {
if (JSON.stringify(value) !== JSON.stringify(oldValue)) {
actions.clearAxis()
}
}
// One action, not one per column, because each dispatch runs the reducers of every mounted logic.
const toAxis = (name: string): SelectedYAxis => ({
name,
settings: oldTabularColumnSettings?.find((n) => n?.name === name)?.settings ?? DefaultAxisSettings(),
})
const tabularColumns =
values.response && values.tabularColumnSettings === null
? value.map((column) => toAxis(column.name))
: null
const defaultAxes =
values.response && values.selectedXAxis === null && values.selectedYAxis === null
? deriveDefaultAxes(value)
: null
const yAxis = defaultAxes?.yAxis.length ? defaultAxes.yAxis.map(toAxis) : null
const xAxis = defaultAxes?.xAxis ?? null
if (tabularColumns?.length || yAxis || xAxis) {
actions.initializeAxes(tabularColumns?.length ? tabularColumns : null, yAxis, xAxis)
}
if (values.effectiveVisualizationType === ChartDisplayType.TwoDimensionalHeatmap) {
applyAutoHeatmapSettings(actions, value, values.chartSettings.heatmap ?? {})
}
if (values.effectiveVisualizationType === ChartDisplayType.BoxPlot) {
actions.updateChartSettings({
boxPlot: getAutoBoxPlotSettings(value, values.chartSettings.boxPlot),
})
}
// The generic setup above only lands a numeric x for a scatter by luck (a DATE column or a
// non-numeric first column). Resolve it explicitly so an all-numeric query, a column change,
// or a persisted/assistant-created scatter still gets a plottable x axis.
if (values.effectiveVisualizationType === ChartDisplayType.ScatterPlot) {
applyScatterXAxis(actions, value, values.selectedXAxis, values.selectedYAxis)
}
},
})),
])