: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 { useActions, useValues } from 'kea'
import { useState } from 'react'
import { IconPencil, IconPlusSmall, IconTrash } from '@posthog/icons'
import { LemonButton, LemonInput, LemonLabel, LemonModal, LemonSelect, LemonTextArea } from '@posthog/lemon-ui'
import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
import { LemonTable } from 'lib/lemon-ui/LemonTable'
import { uuid } from 'lib/utils/dom'
import { SeriesActionFilter } from 'scenes/insights/filters/ActionFilter/ActionFilter'
import { MathAvailability } from 'scenes/insights/filters/ActionFilter/ActionFilterRow/types'
import { cleanSeriesNodes } from 'scenes/insights/filters/ActionFilter/cleanSeriesNodes'
import { SeriesNode } from 'scenes/insights/filters/ActionFilter/seriesNode'
import {
ActionsNode,
CoreEvent,
CoreEventCategory,
DataWarehouseNode,
EventsNode,
NodeKind,
} from '~/queries/schema/schema-general'
import { BaseMathType, ChartDisplayCategory, GroupMathType, PropertyMathType } from '~/types'
import { coreEventsLogic } from './coreEventsLogic'
// Only allow: total count, unique users/groups, and property sum
const ALLOWED_MATH_TYPES = [
BaseMathType.TotalCount,
BaseMathType.UniqueUsers,
GroupMathType.UniqueGroup,
PropertyMathType.Sum,
] as const
const CATEGORY_OPTIONS = [
{ value: CoreEventCategory.Acquisition, label: 'Acquisition', description: 'Sign up, app install' },
{ value: CoreEventCategory.Activation, label: 'Activation', description: 'Onboarding, first core action' },
{
value: CoreEventCategory.Monetization,
label: 'Monetization',
description: 'Purchase, subscription started',
},
{ value: CoreEventCategory.Expansion, label: 'Expansion', description: 'Plan upgraded' },
{ value: CoreEventCategory.Referral, label: 'Referral', description: 'Invite sent' },
{ value: CoreEventCategory.Retention, label: 'Retention', description: 'Repeat purchase' },
{ value: CoreEventCategory.Churn, label: 'Churn', description: 'Subscription canceled' },
{ value: CoreEventCategory.Reactivation, label: 'Reactivation', description: 'Returned after churn' },
]
function getFilterTypeLabel(filter: EventsNode | ActionsNode | DataWarehouseNode): string {
switch (filter.kind) {
case NodeKind.EventsNode:
return 'Event'
case NodeKind.ActionsNode:
return 'Action'
case NodeKind.DataWarehouseNode:
return 'Data warehouse'
default:
return 'Unknown'
}
}
function getFilterSummary(filter: EventsNode | ActionsNode | DataWarehouseNode): string {
switch (filter.kind) {
case NodeKind.EventsNode:
return filter.event || 'All events'
case NodeKind.ActionsNode:
return filter.name || `Action #${filter.id}`
case NodeKind.DataWarehouseNode:
return filter.table_name || 'Unknown table'
default:
return 'Unknown'
}
}
const defaultFilter: EventsNode = {
kind: NodeKind.EventsNode,
event: 'Please select an event, action, or data warehouse table',
}
interface FormState {
id: string | null // null for new, string for editing
name: string
description: string
category: CoreEventCategory | null
filter: EventsNode | ActionsNode | DataWarehouseNode
}
const createEmptyFormState = (): FormState => ({
id: null,
name: '',
description: '',
category: null,
filter: defaultFilter,
})
const eventToFormState = (event: CoreEvent): FormState => ({
id: event.id,
name: event.name,
description: event.description || '',
category: event.category,
filter: event.filter,
})
export function CoreEventsSettings(): JSX.Element {
const { coreEvents } = useValues(coreEventsLogic)
const { addCoreEvent, updateCoreEvent, removeCoreEvent } = useActions(coreEventsLogic)
const [isModalOpen, setIsModalOpen] = useState(false)
const [formState, setFormState] = useState<FormState>(createEmptyFormState)
const isEditing = formState.id !== null
const handleOpenNewModal = (): void => {
setFormState(createEmptyFormState())
setIsModalOpen(true)
}
const handleOpenEditModal = (event: CoreEvent): void => {
setFormState(eventToFormState(event))
setIsModalOpen(true)
}
const handleCloseModal = (): void => {
setIsModalOpen(false)
setFormState(createEmptyFormState())
}
const handleSeriesChange = (series: SeriesNode[]): void => {
// The picker offers events, actions and data warehouse tables only, and cannot combine them.
const [node] = cleanSeriesNodes(series, MathAvailability.All) as CoreEvent['filter'][]
if (node) {
setFormState((prev) => ({
...prev,
filter: node,
// Auto-fill name from event/action name if not already set
name: prev.name || node.name || (node.kind === NodeKind.EventsNode ? node.event : '') || '',
}))
}
}
const handleSave = (): void => {
if (!formState.name.trim() || !formState.category) {
return
}
const event: CoreEvent = {
id: formState.id || uuid(),
name: formState.name.trim(),
description: formState.description.trim() || undefined,
category: formState.category,
filter: formState.filter,
}
if (isEditing) {
updateCoreEvent(event)
} else {
addCoreEvent(event)
}
handleCloseModal()
}
const getDisabledReason = (): string | undefined => {
if (!formState.name.trim()) {
return 'Please enter a name for this core event'
}
const hasValidFilter =
(formState.filter.kind === NodeKind.EventsNode &&
formState.filter.event != defaultFilter.event &&
formState.filter.kind === NodeKind.EventsNode &&
formState.filter.event) ||
(formState.filter.kind === NodeKind.ActionsNode && formState.filter.id !== undefined) ||
(formState.filter.kind === NodeKind.DataWarehouseNode && formState.filter.table_name)
if (!hasValidFilter) {
return 'Please select an event, action, or data warehouse table'
}
if (!formState.category) {
return 'Please select a category'
}
return undefined
}
const disabledReason = getDisabledReason()
return (
<div className="space-y-4">
<div className="flex justify-between items-center">
<h3 className="font-bold">
{coreEvents.length === 0
? 'No core events configured'
: `${coreEvents.length} core event${coreEvents.length === 1 ? '' : 's'}`}
</h3>
<LemonButton type="primary" icon={<IconPlusSmall />} onClick={handleOpenNewModal}>
Add core event
</LemonButton>
</div>
<LemonTable
rowKey={(item) => item.id}
dataSource={coreEvents}
columns={[
{
key: 'name',
title: 'Name',
render: (_, event: CoreEvent) => <span className="font-medium">{event.name}</span>,
},
{
key: 'type',
title: 'Type',
render: (_, event: CoreEvent) => getFilterTypeLabel(event.filter),
},
{
key: 'filter',
title: 'Filter',
render: (_, event: CoreEvent) => (
<span className="text-muted">{getFilterSummary(event.filter)}</span>
),
},
{
key: 'category',
title: 'Category',
render: (_, event: CoreEvent) =>
event.category
? CATEGORY_OPTIONS.find((o) => o.value === event.category)?.label || event.category
: '-',
},
{
key: 'actions',
title: 'Actions',
width: 100,
render: (_, event: CoreEvent) => (
<div className="flex gap-1">
<LemonButton
icon={<IconPencil />}
size="small"
onClick={() => handleOpenEditModal(event)}
tooltip="Edit"
/>
<LemonButton
icon={<IconTrash />}
size="small"
status="danger"
onClick={() => removeCoreEvent(event.id)}
tooltip="Remove"
/>
</div>
),
},
]}
emptyState="No core events configured yet. Add your first core event above."
/>
<LemonModal
isOpen={isModalOpen}
onClose={handleCloseModal}
title={isEditing ? 'Edit core event' : 'Add core event'}
width="40rem"
footer={
<>
<LemonButton onClick={handleCloseModal}>Cancel</LemonButton>
<LemonButton type="primary" onClick={handleSave} disabledReason={disabledReason}>
{isEditing ? 'Update' : 'Add'}
</LemonButton>
</>
}
>
<div className="space-y-4">
<div className="space-y-1">
<LemonLabel>Name</LemonLabel>
<LemonInput
value={formState.name}
onChange={(value) => setFormState((prev) => ({ ...prev, name: value }))}
placeholder="e.g., Purchase, Sign up"
/>
</div>
<div className="space-y-1">
<LemonLabel>Description (optional)</LemonLabel>
<LemonTextArea
value={formState.description}
onChange={(value) => setFormState((prev) => ({ ...prev, description: value }))}
placeholder="Describe what this core event tracks"
/>
</div>
<div className="space-y-1">
<LemonLabel>Event, action, or data warehouse table</LemonLabel>
<SeriesActionFilter
bordered
series={[formState.filter]}
onChange={handleSeriesChange}
trendsDisplayCategory={ChartDisplayCategory.TimeSeries}
typeKey="core-events-settings"
mathAvailability={MathAvailability.All}
allowedMathTypes={ALLOWED_MATH_TYPES}
hideRename
hideDuplicate
showSeriesIndicator={false}
entitiesLimit={1}
actionsTaxonomicGroupTypes={[
TaxonomicFilterGroupType.Events,
TaxonomicFilterGroupType.Actions,
TaxonomicFilterGroupType.DataWarehouse,
]}
excludedProperties={{
[TaxonomicFilterGroupType.Events]: [null],
}}
/>
</div>
<div className="space-y-1">
<LemonLabel>Category</LemonLabel>
<LemonSelect
value={formState.category}
onChange={(value) => setFormState((prev) => ({ ...prev, category: value }))}
options={CATEGORY_OPTIONS}
placeholder="Select a category"
/>
</div>
</div>
</LemonModal>
</div>
)
}