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.

15.2 KB
Raw Blame
import './ColumnConfigurator.scss'

import { DndContext } from '@dnd-kit/core'
import { restrictToParentElement, restrictToVerticalAxis } from '@dnd-kit/modifiers'
import { SortableContext, useSortable, verticalListSortingStrategy } from '@dnd-kit/sortable'
import { CSS } from '@dnd-kit/utilities'
import { BindLogic, useActions, useValues } from 'kea'
import { useState } from 'react'

import { IconPencil, IconX } from '@posthog/icons'

import { AutoSizer } from 'lib/components/AutoSizer'
import { PropertyFilterIcon } from 'lib/components/PropertyFilters/components/PropertyFilterIcon'
import { PropertyKeyInfo } from 'lib/components/PropertyKeyInfo'
import { RestrictionScope, useRestrictedArea } from 'lib/components/RestrictedArea'
import { TaxonomicFilter } from 'lib/components/TaxonomicFilter/TaxonomicFilter'
import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
import { TeamMembershipLevel } from 'lib/constants'
import { IconTuning, SortableDragIcon } from 'lib/lemon-ui/icons'
import { LemonButton } from 'lib/lemon-ui/LemonButton'
import { LemonCheckbox } from 'lib/lemon-ui/LemonCheckbox'
import { LemonModal } from 'lib/lemon-ui/LemonModal'
import { Tooltip } from 'lib/lemon-ui/Tooltip'

import { dataTableLogic } from '~/queries/nodes/DataTable/dataTableLogic'
import { isActorsQuery } from '~/queries/schema/node-guards'
import { DataTableNode } from '~/queries/schema/schema-general'
import {
    isEventsQuery,
    isGroupsQuery,
    isSessionsQuery,
    taxonomicEventFilterToHogQL,
    taxonomicGroupFilterToHogQL,
    taxonomicPersonFilterToHogQL,
    taxonomicSessionFilterToHogQL,
    trimQuotes,
} from '~/queries/utils'
import { GroupTypeIndex, PropertyFilterType } from '~/types'

import { defaultDataTableColumns, extractExpressionComment, removeExpressionComment } from '../utils'
import { ColumnConfiguratorLogicProps, columnConfiguratorLogic } from './columnConfiguratorLogic'

let uniqueNode = 0

interface ColumnConfiguratorProps {
    query: DataTableNode
    setQuery?: (query: DataTableNode) => void
}

export function ColumnConfigurator({ query, setQuery }: ColumnConfiguratorProps): JSX.Element {
    const { columnsInQuery } = useValues(dataTableLogic)

    // users should not be able to edit the '*' column
    const hasStarColumn = columnsInQuery.includes('*')
    const configurableColumns = columnsInQuery.filter((c) => c !== '*')

    const [key] = useState(() => String(uniqueNode++))
    const columnConfiguratorLogicProps: ColumnConfiguratorLogicProps = {
        key,
        isPersistent: !!query.showPersistentColumnConfigurator,
        columns: configurableColumns,
        setColumns: (columns: string[]) => {
            const allColumns = hasStarColumn ? ['*', ...columns] : columns
            // Strip stale `columns` from queryWithDefaults — source.select is the source of truth
            const { columns: _discardColumns, ...queryWithoutColumns } = query
            if (isEventsQuery(query.source) || isSessionsQuery(query.source)) {
                let orderBy = query.source.orderBy
                if (orderBy && orderBy.length > 0) {
                    const orderColumn = removeExpressionComment(
                        orderBy[0].endsWith(' DESC') ? orderBy[0].replace(/ DESC$/, '') : orderBy[0]
                    )
                    // the old orderBy column was removed, so remove it from the new query
                    if (!columns.some((c) => removeExpressionComment(c) === orderColumn)) {
                        orderBy = undefined
                    }
                }
                setQuery?.({
                    ...queryWithoutColumns,
                    source: {
                        ...query.source,
                        orderBy,
                        select: allColumns,
                    },
                })
            } else if (isActorsQuery(query.source) || isGroupsQuery(query.source)) {
                setQuery?.({
                    ...queryWithoutColumns,
                    source: {
                        ...query.source,
                        select: allColumns,
                    },
                })
            } else {
                setQuery?.({ ...query, columns: allColumns })
            }
        },
        context: query.context
            ? query.context
            : isGroupsQuery(query.source)
              ? { type: 'groups', groupTypeIndex: query.source.group_type_index as GroupTypeIndex }
              : { type: 'team_columns' },
        contextKey: query.contextKey,
        showTableViews: query.showTableViews,
    }
    const { showModal } = useActions(columnConfiguratorLogic(columnConfiguratorLogicProps))

    return (
        <BindLogic logic={columnConfiguratorLogic} props={columnConfiguratorLogicProps}>
            <LemonButton
                type="secondary"
                data-attr="events-table-column-selector"
                icon={<IconTuning />}
                onClick={showModal}
                size="small"
            >
                Configure columns
            </LemonButton>
            <ColumnConfiguratorModal query={query} setQuery={setQuery} />
        </BindLogic>
    )
}

function ColumnConfiguratorModal({ query }: ColumnConfiguratorProps): JSX.Element {
    const restrictionReason = useRestrictedArea({
        minimumAccessLevel: TeamMembershipLevel.Admin,
        scope: RestrictionScope.Project,
    })
    const { modalVisible, columns, saveAsDefault } = useValues(columnConfiguratorLogic)
    const { hideModal, moveColumn, setColumns, selectColumn, unselectColumn, save, toggleSaveAsDefault } =
        useActions(columnConfiguratorLogic)
    const { context } = useValues(columnConfiguratorLogic)

    const onEditColumn = (column: string, index: number): void => {
        const newColumn = window.prompt('Edit column', column)
        if (newColumn) {
            setColumns(columns.map((c, i) => (i === index ? newColumn : c)))
        }
    }

    let taxonomicGroupTypes: TaxonomicFilterGroupType[] = []
    if (isGroupsQuery(query.source)) {
        taxonomicGroupTypes = [
            `${TaxonomicFilterGroupType.GroupsPrefix}_${query.source.group_type_index}` as TaxonomicFilterGroupType,
            TaxonomicFilterGroupType.HogQLExpression,
        ]
    } else if (isActorsQuery(query.source)) {
        taxonomicGroupTypes = [TaxonomicFilterGroupType.PersonProperties, TaxonomicFilterGroupType.HogQLExpression]
    } else if (isSessionsQuery(query.source)) {
        taxonomicGroupTypes = [
            TaxonomicFilterGroupType.SessionProperties,
            TaxonomicFilterGroupType.PersonProperties,
            TaxonomicFilterGroupType.HogQLExpression,
        ]
    } else {
        taxonomicGroupTypes = [
            TaxonomicFilterGroupType.EventProperties,
            TaxonomicFilterGroupType.EventFeatureFlags,
            TaxonomicFilterGroupType.PersonProperties,
            ...(isEventsQuery(query.source)
                ? [TaxonomicFilterGroupType.SessionProperties, TaxonomicFilterGroupType.HogQLExpression]
                : []),
        ]
    }

    const showPersistedColumnReorder =
        isEventsQuery(query.source) ||
        isGroupsQuery(query.source) ||
        isSessionsQuery(query.source) ||
        isActorsQuery(query.source)

    return (
        <LemonModal
            isOpen={modalVisible}
            title="Configure columns"
            onClose={hideModal}
            footer={
                <>
                    <div className="flex-1 flex flex-wrap items-center gap-2">
                        <LemonButton
                            type="secondary"
                            onClick={() =>
                                setColumns(query.defaultColumns || defaultDataTableColumns(query.source.kind))
                            }
                        >
                            Reset to defaults
                        </LemonButton>
                        {showPersistedColumnReorder && query.showPersistentColumnConfigurator && (
                            <LemonCheckbox
                                label={
                                    context?.type === 'groups'
                                        ? 'Save as default columns for this group type'
                                        : context?.type === 'event_definition'
                                          ? 'Save as default columns for this event type'
                                          : 'Save as default for all project members'
                                }
                                data-attr="events-table-save-columns-as-default-toggle"
                                checked={saveAsDefault}
                                onChange={toggleSaveAsDefault}
                                disabledReason={restrictionReason}
                            />
                        )}
                    </div>
                    <LemonButton type="secondary" onClick={hideModal}>
                        Close
                    </LemonButton>
                    <LemonButton type="primary" onClick={save} data-attr="items-selector-confirm">
                        Save
                    </LemonButton>
                </>
            }
            className="w-full max-w-248"
        >
            <div className="ColumnConfiguratorModal">
                <div className="flex flex-col gap-4">
                    <div className="w-full">
                        <h4 className="secondary uppercase text-secondary">
                            Visible columns ({columns.length}) - Drag to reorder
                        </h4>
                        <DndContext
                            onDragEnd={({ active, over }) => {
                                if (over && active.id !== over.id) {
                                    moveColumn(
                                        columns.indexOf(active.id.toString()),
                                        columns.indexOf(over.id.toString())
                                    )
                                }
                            }}
                            modifiers={[restrictToVerticalAxis, restrictToParentElement]}
                        >
                            <SortableContext items={columns} strategy={verticalListSortingStrategy}>
                                {columns.map((column, index) => (
                                    <SelectedColumn
                                        key={column}
                                        column={column}
                                        dataIndex={index}
                                        onEdit={onEditColumn}
                                        onRemove={unselectColumn}
                                    />
                                ))}
                            </SortableContext>
                        </DndContext>
                    </div>
                    <div className="w-full">
                        <h4 className="secondary uppercase text-secondary">Available columns</h4>
                        <div className="h-[min(480px,60vh)]">
                            <AutoSizer
                                renderProp={({ height, width }) =>
                                    height && width ? (
                                        <TaxonomicFilter
                                            height={height}
                                            width={width}
                                            taxonomicGroupTypes={taxonomicGroupTypes}
                                            value={undefined}
                                            onChange={(group, value) => {
                                                const column = isGroupsQuery(query.source)
                                                    ? taxonomicGroupFilterToHogQL(group.type, value)
                                                    : isActorsQuery(query.source)
                                                      ? taxonomicPersonFilterToHogQL(group.type, value)
                                                      : isSessionsQuery(query.source)
                                                        ? taxonomicSessionFilterToHogQL(group.type, value)
                                                        : taxonomicEventFilterToHogQL(group.type, value)
                                                if (column !== null) {
                                                    selectColumn(column)
                                                }
                                            }}
                                            popoverEnabled={false}
                                            selectFirstItem={false}
                                            selectingKeyOnly
                                        />
                                    ) : null
                                }
                            />
                        </div>
                    </div>
                </div>
            </div>
        </LemonModal>
    )
}

const SelectedColumn = ({
    column,
    dataIndex,
    onEdit,
    onRemove,
}: {
    column: string
    dataIndex: number
    onEdit: (column: string, index: number) => void
    onRemove: (column: string) => void
}): JSX.Element => {
    const { setNodeRef, attributes, transform, transition, listeners } = useSortable({ id: column })

    let columnType: PropertyFilterType | null = null
    let filterGroupType: TaxonomicFilterGroupType | undefined
    let columnKey = column
    if (column.startsWith('person.properties.')) {
        columnType = PropertyFilterType.Person
        filterGroupType = TaxonomicFilterGroupType.PersonProperties
        columnKey = column.substring(18)
    }
    if (column.startsWith('properties.')) {
        columnType = PropertyFilterType.Event
        columnKey = column.substring(11)
    }
    if (column.startsWith('session.')) {
        columnType = PropertyFilterType.Session
        filterGroupType = TaxonomicFilterGroupType.SessionProperties
        columnKey = column.substring(8)
    }

    columnKey = trimQuotes(extractExpressionComment(columnKey))

    return (
        <div
            ref={setNodeRef}
            // eslint-disable-next-line react/forbid-dom-props
            style={{
                transform: CSS.Transform.toString(transform),
                transition,
            }}
            {...attributes}
        >
            <div className="SelectedColumn">
                <span {...listeners} className="drag-handle">
                    <SortableDragIcon />
                </span>
                {columnType && <PropertyFilterIcon type={columnType} />}
                <PropertyKeyInfo
                    className="ml-1"
                    value={columnKey}
                    type={filterGroupType || TaxonomicFilterGroupType.EventProperties}
                />
                <div className="flex-1" />
                <Tooltip title="Edit">
                    <LemonButton onClick={() => onEdit(column, dataIndex)} size="small">
                        <IconPencil data-attr="column-display-item-edit-icon" />
                    </LemonButton>
                </Tooltip>
                <Tooltip title="Remove">
                    <LemonButton onClick={() => onRemove(column)} status="danger" size="small">
                        <IconX data-attr="column-display-item-remove-icon" />
                    </LemonButton>
                </Tooltip>
            </div>
        </div>
    )
}