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.

22.8 KB
Raw Blame
import { useActions, useValues } from 'kea'
import { Form } from 'kea-forms'
import { createRef } from 'react'

import { IconImage } from '@posthog/icons'
import { LemonSkeleton, LemonTag } from '@posthog/lemon-ui'
import { Button } from '@posthog/quill'

import { PropertyStatusControl } from 'lib/components/DefinitionPopover/DefinitionPopoverContents'
import { FlaggedFeature } from 'lib/components/FlaggedFeature'
import { ImageCarousel } from 'lib/components/ImageCarousel/ImageCarousel'
import { MemberSelect } from 'lib/components/MemberSelect'
import { NotFound } from 'lib/components/NotFound'
import { ObjectTags } from 'lib/components/ObjectTags/ObjectTags'
import { PayGateMini } from 'lib/components/PayGateMini/PayGateMini'
import { PropertyKeyInfo } from 'lib/components/PropertyKeyInfo'
import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
import { TaxonomicPopover } from 'lib/components/TaxonomicPopover/TaxonomicPopover'
import { FEATURE_FLAGS } from 'lib/constants'
import { useFeatureFlag } from 'lib/hooks/useFeatureFlag'
import { useUploadFiles } from 'lib/hooks/useUploadFiles'
import { LemonButton } from 'lib/lemon-ui/LemonButton'
import { LemonField } from 'lib/lemon-ui/LemonField'
import { LemonFileInput } from 'lib/lemon-ui/LemonFileInput/LemonFileInput'
import { LemonLabel } from 'lib/lemon-ui/LemonLabel/LemonLabel'
import { LemonSelect } from 'lib/lemon-ui/LemonSelect'
import { LemonTextArea } from 'lib/lemon-ui/LemonTextArea/LemonTextArea'
import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { LinkPrimitive } from 'lib/lemon-ui/Link'
import { preflightLogic } from 'lib/logic/preflightLogic'
import { getPrimaryPropertyForEvent, hasTaxonomyPrimaryProperty } from 'lib/utils/events'
import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
import { definitionEditLogic } from 'scenes/data-management/definition/definitionEditLogic'
import {
    DefinitionLogicProps,
    decodeDefinitionId,
    definitionLogic,
} from 'scenes/data-management/definition/definitionLogic'
import { PropertyAccessControl } from 'scenes/data-management/definition/PropertyAccessControl'
import { SceneExport } from 'scenes/sceneTypes'
import { teamLogic } from 'scenes/teamLogic'
import { urls } from 'scenes/urls'

import { SceneContent } from '~/layout/scenes/components/SceneContent'
import { SceneDivider } from '~/layout/scenes/components/SceneDivider'
import { SceneSection } from '~/layout/scenes/components/SceneSection'
import { SceneTitleSection } from '~/layout/scenes/components/SceneTitleSection'
import { tagsModel } from '~/models/tagsModel'
import { isCoreFilter } from '~/taxonomy/helpers'
import { AvailableFeature, ObjectMediaPreview } from '~/types'

import { getEventDefinitionIcon, getPropertyDefinitionIcon } from '../events/DefinitionHeader'

export const scene: SceneExport<DefinitionLogicProps> = {
    component: DefinitionEdit,
    logic: definitionLogic,
    paramsToProps: ({ params: { id } }) => ({ id: decodeDefinitionId(id) }),
}

export function DefinitionEdit(rawProps: DefinitionLogicProps): JSX.Element {
    // The app renders scene components with raw route params, so decode the id like paramsToProps does
    const props = { ...rawProps, id: decodeDefinitionId(rawProps.id) }
    const logic = definitionEditLogic(props)
    const definitionLogicInstance = definitionLogic(props)
    const { definitionLoading, definitionMissing, isProperty, singular } = useValues(definitionLogicInstance)
    const { editDefinition } = useValues(logic)
    const { saveDefinition } = useActions(logic)
    const { tags, tagsLoading } = useValues(tagsModel)
    const { currentTeamId } = useValues(teamLogic)
    const { objectStorageAvailable } = useValues(preflightLogic)
    const { reportMediaPreviewUploaded } = useActions(eventUsageLogic)
    const todayRailNav = useFeatureFlag('TODAY_RAIL_NAV')

    const allowVerification = !isCoreFilter(editDefinition.name) && 'verified' in editDefinition

    const showHiddenOption = 'hidden' in editDefinition

    const { previews, previewsLoading } = useValues(definitionLogicInstance)
    // A preview without a URL has nothing to show, and the delete handler below matches previews by URL
    const visiblePreviews = previews?.filter((p: ObjectMediaPreview) => p.media_url) ?? []
    const { createMediaPreview, deleteMediaPreview } = useActions(definitionLogicInstance)

    const { setFilesToUpload, filesToUpload, uploading } = useUploadFiles({
        onUpload: (_url, _fileName, uploadedMediaId) => {
            createMediaPreview(uploadedMediaId)
            reportMediaPreviewUploaded('definition_edit')
        },
        onError: (detail) => {
            lemonToast.error(`Error uploading image: ${detail}`)
        },
    })

    const mediaPreviewDragTarget = createRef<HTMLDivElement>()

    if (definitionMissing) {
        return <NotFound object={singular} />
    }
    return (
        <Form logic={definitionEditLogic} props={props} formKey="editDefinition">
            <SceneContent>
                <SceneTitleSection
                    name={editDefinition.name}
                    resourceType={{
                        type: isProperty ? 'property definition' : 'event definition',
                        forceIcon: isProperty
                            ? getPropertyDefinitionIcon(editDefinition)
                            : getEventDefinitionIcon(editDefinition),
                    }}
                    forceBackTo={
                        isProperty
                            ? {
                                  path: urls.propertyDefinitions(),
                                  name: 'Property definitions',
                                  key: 'properties',
                              }
                            : {
                                  path: urls.eventDefinitions(),
                                  name: 'Event definitions',
                                  key: 'events',
                              }
                    }
                    actions={
                        todayRailNav ? (
                            <>
                                <Button
                                    data-attr="save-definition"
                                    variant="primary"
                                    onClick={() => {
                                        saveDefinition({})
                                    }}
                                    disabledReason={definitionLoading ? 'Loading...' : undefined}
                                >
                                    Save
                                </Button>
                                <Button
                                    data-attr="cancel-definition"
                                    variant="outline"
                                    render={
                                        <LinkPrimitive
                                            to={
                                                !isProperty
                                                    ? urls.eventDefinition(editDefinition.id)
                                                    : urls.propertyDefinition(editDefinition.id)
                                            }
                                        />
                                    }
                                    disabledReason={definitionLoading ? 'Loading...' : undefined}
                                >
                                    Cancel
                                </Button>
                            </>
                        ) : (
                            <>
                                <LemonButton
                                    data-attr="save-definition"
                                    type="primary"
                                    size="small"
                                    onClick={() => {
                                        saveDefinition({})
                                    }}
                                    disabledReason={definitionLoading ? 'Loading...' : undefined}
                                >
                                    Save
                                </LemonButton>
                                <LemonButton
                                    data-attr="cancel-definition"
                                    type="secondary"
                                    size="small"
                                    to={
                                        !isProperty
                                            ? urls.eventDefinition(editDefinition.id)
                                            : urls.propertyDefinition(editDefinition.id)
                                    }
                                    disabledReason={definitionLoading ? 'Loading...' : undefined}
                                >
                                    Cancel
                                </LemonButton>
                            </>
                        )
                    }
                />

                {definitionLoading ? (
                    <div className="deprecated-space-y-4">
                        <LemonSkeleton className="h-10 w-1/3" />
                        <LemonSkeleton className="h-6 w-1/2" />
                        <LemonSkeleton className="h-30 w-1/2" />
                    </div>
                ) : (
                    <div className="deprecated-space-y-4">
                        <div className="flex flex-wrap items-center gap-2 text-secondary">
                            <div>{isProperty ? 'Property' : 'Event'} name:</div>
                            <LemonTag className="font-mono">{editDefinition.name}</LemonTag>
                        </div>
                        {'tags' in editDefinition && (
                            <div className="ph-ignore-input">
                                <LemonField name="tags" label="Tags" data-attr="definition-tags">
                                    {({ value, onChange }) => (
                                        <ObjectTags
                                            className="definition-tags"
                                            saving={definitionLoading || tagsLoading}
                                            tags={value || []}
                                            onChange={(tags) => onChange(tags)}
                                            style={{ marginBottom: 4 }}
                                            tagsAvailable={tags}
                                        />
                                    )}
                                </LemonField>
                            </div>
                        )}

                        <div className="ph-ignore-input">
                            <LemonField name="description" label="Description" data-attr="definition-description">
                                <LemonTextArea value={editDefinition.description} />
                            </LemonField>
                        </div>

                        {'owner' in editDefinition && (
                            <div className="ph-ignore-input">
                                <LemonField name="owner" label="Owner" className="w-60" data-attr="definition-owner">
                                    {({ value, onChange }) => (
                                        <MemberSelect
                                            value={value?.id ?? null}
                                            onChange={onChange}
                                            defaultLabel="No owner"
                                            data-attr="definition-owner-select"
                                        />
                                    )}
                                </LemonField>
                            </div>
                        )}

                        {/* Allow uploading media previews only for custom events; not that useful for properties or autocapture events */}
                        {objectStorageAvailable && !isProperty && !isCoreFilter(editDefinition.name) && (
                            <div className="ph-ignore-input">
                                <LemonField
                                    name="media_preview"
                                    label={
                                        <LemonLabel info="Previews show where a client side event is triggered. Upload a screenshot or design.">
                                            Media preview
                                        </LemonLabel>
                                    }
                                >
                                    <div>
                                        <div
                                            ref={mediaPreviewDragTarget}
                                            className="mb-4 border-2 border-dashed rounded p-4 flex items-center justify-center cursor-pointer"
                                            onClick={(e) => {
                                                if (e.target === e.currentTarget) {
                                                    const input = mediaPreviewDragTarget.current?.querySelector(
                                                        'input[type="file"]'
                                                    ) as HTMLInputElement
                                                    input?.click()
                                                }
                                            }}
                                        >
                                            <LemonFileInput
                                                accept="image/*"
                                                multiple={false}
                                                onChange={setFilesToUpload}
                                                loading={uploading}
                                                value={filesToUpload}
                                                alternativeDropTargetRef={mediaPreviewDragTarget}
                                                callToAction={
                                                    <div className="flex items-center gap-2">
                                                        <IconImage />
                                                        <span>Click or drag and drop to upload an image</span>
                                                    </div>
                                                }
                                            />
                                        </div>

                                        {(previewsLoading || visiblePreviews.length > 0) && (
                                            <ImageCarousel
                                                loading={previewsLoading}
                                                imageUrls={visiblePreviews.map((p: ObjectMediaPreview) => p.media_url)}
                                                onDelete={(url: string) => {
                                                    const preview = visiblePreviews.find(
                                                        (p: ObjectMediaPreview) => p.media_url === url
                                                    )
                                                    if (preview) {
                                                        deleteMediaPreview(preview.id)
                                                    }
                                                }}
                                            />
                                        )}
                                    </div>
                                </LemonField>
                            </div>
                        )}

                        {(allowVerification || showHiddenOption) && (
                            <div className="ph-ignore-input">
                                <LemonField name="verified" label="Status" data-attr="definition-status">
                                    {({ value: verified, onChange }) => (
                                        <LemonField name="hidden">
                                            {({ value: hidden, onChange: onHiddenChange }) => (
                                                <PropertyStatusControl
                                                    isProperty={isProperty}
                                                    verified={!!verified}
                                                    hidden={!!hidden}
                                                    showHiddenOption={showHiddenOption}
                                                    allowVerification={allowVerification}
                                                    onChange={({ verified: newVerified, hidden: newHidden }) => {
                                                        onChange(newVerified)
                                                        onHiddenChange(newHidden)
                                                    }}
                                                />
                                            )}
                                        </LemonField>
                                    )}
                                </LemonField>
                            </div>
                        )}

                        {isProperty && (
                            <div className="ph-ignore-input">
                                <LemonField name="property_type" label="Property Type" data-attr="property-type">
                                    {({ value, onChange }) => (
                                        <LemonSelect
                                            onChange={(val) => onChange(val)}
                                            value={value as 'DateTime' | 'String' | 'Numeric' | 'Boolean'}
                                            options={[
                                                { value: 'DateTime', label: 'DateTime' },
                                                { value: 'String', label: 'String' },
                                                { value: 'Numeric', label: 'Numeric' },
                                                { value: 'Boolean', label: 'Boolean' },
                                            ]}
                                        />
                                    )}
                                </LemonField>
                            </div>
                        )}

                        {!isProperty &&
                            hasTaxonomyPrimaryProperty(editDefinition.name) &&
                            (() => {
                                const taxonomyValue = getPrimaryPropertyForEvent(editDefinition.name)
                                if (!taxonomyValue) {
                                    return null
                                }
                                return (
                                    <div className="ph-ignore-input">
                                        <LemonLabel info="This event has a built-in primary property that PostHog ships with — it can't be overridden on a per-team basis.">
                                            Primary property
                                        </LemonLabel>
                                        <div
                                            className="flex items-center gap-2 mt-1"
                                            data-attr="definition-primary-property-builtin"
                                        >
                                            <PropertyKeyInfo
                                                value={taxonomyValue}
                                                type={TaxonomicFilterGroupType.EventProperties}
                                                disableIcon
                                            />
                                            <LemonTag type="muted" size="small">
                                                Built-in
                                            </LemonTag>
                                        </div>
                                    </div>
                                )
                            })()}

                        {!isProperty && !hasTaxonomyPrimaryProperty(editDefinition.name) && (
                            <div className="ph-ignore-input">
                                <LemonField
                                    name="primary_property"
                                    label={
                                        <LemonLabel info="When set, PostHog surfaces like the session replay inspector show this property's value alongside the event. Choose the single property that best summarizes each occurrence of the event.">
                                            Primary property
                                        </LemonLabel>
                                    }
                                    data-attr="definition-primary-property"
                                >
                                    {({ value, onChange }) => (
                                        <TaxonomicPopover<string>
                                            allowClear
                                            data-attr="definition-primary-property-picker"
                                            groupType={TaxonomicFilterGroupType.EventProperties}
                                            eventNames={[editDefinition.name]}
                                            value={value ?? null}
                                            onChange={(changedValue) =>
                                                onChange(typeof changedValue === 'string' ? changedValue : null)
                                            }
                                            placeholder="Select a primary property"
                                            selectingKeyOnly
                                        />
                                    )}
                                </LemonField>
                            </div>
                        )}
                    </div>
                )}

                {isProperty && editDefinition.id !== 'new' && currentTeamId && (
                    <FlaggedFeature flag={FEATURE_FLAGS.PROPERTY_ACCESS_CONTROL}>
                        <SceneDivider />
                        <SceneSection
                            title="Access control"
                            description="Control who can see this property's values, and who can edit them from the PostHog UI."
                        >
                            <PayGateMini
                                feature={AvailableFeature.PROPERTY_ACCESS_CONTROL}
                                featureDetail="property-definition-access-control"
                            >
                                <PropertyAccessControl
                                    propertyDefinitionId={editDefinition.id}
                                    teamId={currentTeamId}
                                />
                            </PayGateMini>
                        </SceneSection>
                    </FlaggedFeature>
                )}
            </SceneContent>
        </Form>
    )
}