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.

11.3 KB
Raw Blame
import { LogicWrapper, useValues } from 'kea'
import { Form } from 'kea-forms'

import { IconCheck, IconPencil, IconPlus, IconTrash, IconX } from '@posthog/icons'
import { LemonBanner, LemonButton, LemonDialog, LemonInput, LemonLabel, lemonToast } from '@posthog/lemon-ui'

import { RestrictionScope, useRestrictedArea } from 'lib/components/RestrictedArea'
import { TeamMembershipLevel } from 'lib/constants'
import { LemonField } from 'lib/lemon-ui/LemonField'
import { cn } from 'lib/utils/css-classes'
import { AiRegexHelper, AiRegexHelperButton } from 'scenes/session-recordings/components/AiRegexHelper/AiRegexHelper'

import { ingestionControlsLogic } from '../ingestionControlsLogic'
import { UrlTriggerConfig } from '../types'

export function UrlConfig({
    logic,
    logicProps,
    formKey,
    addUrl,
    validationWarning,
    title,
    description,
    checkUrl,
    checkUrlResults,
    setCheckUrl,
    titleBadge,
    ...props
}: {
    logic: LogicWrapper
    logicProps: Record<string, any>
    formKey: string
    addUrl: (urlTriggerConfig: UrlTriggerConfig) => void
    validationWarning: string | null
    title: string
    titleBadge?: JSX.Element
    description: string
    checkUrl: string
    checkUrlResults: { [key: number]: boolean }
    setCheckUrl: (url: string) => void
    isAddFormVisible: boolean
    config: UrlTriggerConfig[] | null
    editIndex: number | null
    isSubmitting: boolean
    onAdd: () => void
    onCancel: () => void
    onEdit: (index: number) => void
    onRemove: (index: number) => void
}): JSX.Element {
    const { logicKey } = useValues(ingestionControlsLogic)
    const restrictedReason = useRestrictedArea({
        scope: RestrictionScope.Project,
        minimumAccessLevel: TeamMembershipLevel.Admin,
    })

    return (
        <div className="flex flex-col gap-y-2">
            <div className="flex items-center gap-2 justify-between">
                <LemonLabel className="text-base">
                    {title}
                    {titleBadge ? <> {titleBadge}</> : null}
                </LemonLabel>
                <LemonButton
                    onClick={props.onAdd}
                    type="secondary"
                    icon={<IconPlus />}
                    data-attr={`${logicKey}-add-url`}
                    size="small"
                    disabledReason={restrictedReason}
                >
                    Add
                </LemonButton>
            </div>
            <p>{description}</p>

            {props.isAddFormVisible && (
                <UrlConfigForm
                    logic={logic}
                    logicProps={logicProps}
                    formKey={formKey}
                    addUrl={addUrl}
                    validationWarning={validationWarning}
                    onCancel={props.onCancel}
                    isSubmitting={props.isSubmitting}
                />
            )}

            {!props.isAddFormVisible && props.config && props.config.length > 0 && (
                <div className="border rounded p-3 bg-surface-primary">
                    <LemonLabel className="text-sm font-medium mb-2 block">
                        Test a full URL against these patterns:
                    </LemonLabel>
                    <LemonInput
                        value={checkUrl}
                        onChange={setCheckUrl}
                        placeholder="e.g., https://example.com/checkout?step=2"
                        data-attr="url-check-input"
                        className="mb-2"
                    />
                    {checkUrl && (
                        <div className="text-xs text-muted">
                            {Object.values(checkUrlResults).some(Boolean) ? (
                                <span className="text-success">✓ This URL matches at least one pattern</span>
                            ) : (
                                <span className="text-danger">
                                    ✗ This URL doesn't match any patterns. Patterns match the full URL, so a path on its
                                    own never matches.
                                </span>
                            )}
                        </div>
                    )}
                </div>
            )}
            {props.config?.map((trigger, index) => (
                <UrlConfigRow
                    logic={logic}
                    logicProps={logicProps}
                    formKey={formKey}
                    addUrl={addUrl}
                    validationWarning={validationWarning}
                    key={`${trigger.url}-${trigger.matching}`}
                    trigger={trigger}
                    index={index}
                    editIndex={props.editIndex}
                    onEdit={props.onEdit}
                    onRemove={props.onRemove}
                    checkUrlResult={checkUrlResults[index]}
                />
            ))}
        </div>
    )
}

function UrlConfigRow({
    trigger,
    index,
    editIndex,
    onEdit,
    onRemove,
    checkUrlResult,
    logic,
    logicProps,
    formKey,
    addUrl,
    validationWarning,
}: {
    trigger: UrlTriggerConfig
    index: number
    editIndex: number | null
    onEdit: (index: number) => void
    onRemove: (index: number) => void
    checkUrlResult?: boolean
    logic: LogicWrapper
    logicProps: Record<string, any>
    formKey: string
    addUrl: (urlTriggerConfig: UrlTriggerConfig) => void
    validationWarning: string | null
}): JSX.Element {
    const restrictedReason = useRestrictedArea({
        scope: RestrictionScope.Project,
        minimumAccessLevel: TeamMembershipLevel.Admin,
    })

    if (editIndex === index) {
        return (
            <div className="border rounded p-2 bg-surface-primary">
                <UrlConfigForm
                    logic={logic}
                    logicProps={logicProps}
                    formKey={formKey}
                    addUrl={addUrl}
                    validationWarning={validationWarning}
                    onCancel={() => onEdit(-1)}
                    isSubmitting={false}
                />
            </div>
        )
    }

    return (
        <div
            className={cn('border rounded flex items-center p-2 pl-4 bg-surface-primary', {
                'border-success': checkUrlResult === true,
                'border-danger': checkUrlResult === false,
            })}
        >
            <span title={trigger.url} className="flex-1 truncate">
                <span>{trigger.matching === 'regex' ? 'Matches regex: ' : ''}</span>
                <span>{trigger.url}</span>
                {checkUrlResult !== undefined && (
                    <span
                        className={cn('ml-2 text-xs', {
                            'text-success': checkUrlResult === true,
                            'text-danger': checkUrlResult === false,
                        })}
                    >
                        {checkUrlResult ? (
                            <>
                                <IconCheck /> Matches
                            </>
                        ) : (
                            <>
                                <IconX /> No match
                            </>
                        )}
                    </span>
                )}
            </span>
            <div className="Actions flex deprecated-space-x-1 shrink-0">
                <LemonButton
                    icon={<IconPencil />}
                    onClick={() => onEdit(index)}
                    tooltip="Edit"
                    center
                    disabledReason={restrictedReason}
                >
                    Edit
                </LemonButton>

                <LemonButton
                    icon={<IconTrash />}
                    tooltip="Remove URL"
                    center
                    onClick={() => {
                        LemonDialog.open({
                            title: <>Remove URL</>,
                            description: 'Are you sure you want to remove this URL?',
                            primaryButton: {
                                status: 'danger',
                                children: 'Remove',
                                onClick: () => onRemove(index),
                            },
                            secondaryButton: {
                                children: 'Cancel',
                            },
                        })
                    }}
                    disabledReason={restrictedReason}
                >
                    Remove
                </LemonButton>
            </div>
        </div>
    )
}

function UrlConfigForm({
    onCancel,
    isSubmitting,
    logic,
    logicProps,
    formKey,
    validationWarning,
    addUrl,
}: {
    onCancel: () => void
    isSubmitting: boolean
    logic: LogicWrapper
    logicProps: Record<string, any>
    formKey: string
    addUrl: (urlTriggerConfig: UrlTriggerConfig) => void
    validationWarning: string | null
}): JSX.Element {
    return (
        <Form
            logic={logic}
            props={logicProps}
            formKey={formKey}
            enableFormOnSubmit
            className="w-full flex flex-col border rounded items-center p-2 pl-4 bg-surface-primary gap-2"
        >
            <div className="flex flex-col gap-2 w-full">
                <LemonBanner type="info" className="text-sm">
                    Patterns are wrapped in <code className="inline">^</code> and <code className="inline">$</code> and
                    matched against the full URL, so a path on its own never matches. Write the full URL, e.g.{' '}
                    <code className="inline">https://example.com/checkout.*</code>
                </LemonBanner>
                <LemonLabel className="w-full">
                    Matching regex:
                    <LemonField name="url" className="flex-1">
                        <LemonInput
                            autoFocus
                            placeholder="e.g., https://example.com/checkout.*, ^https://example.com/page$"
                            data-attr="url-input"
                        />
                    </LemonField>
                </LemonLabel>
                {validationWarning && <span className="text-danger">{validationWarning}</span>}
            </div>
            <div className="flex justify-between gap-2 w-full">
                <div>
                    <AiRegexHelper
                        onApply={(regex) => {
                            try {
                                addUrl({
                                    url: regex,
                                    matching: 'regex',
                                })
                            } catch {
                                lemonToast.error('Failed to apply regex')
                            }
                        }}
                    />
                    <AiRegexHelperButton />
                </div>

                <div className="flex gap-2">
                    <LemonButton type="secondary" onClick={onCancel}>
                        Cancel
                    </LemonButton>
                    <LemonButton
                        htmlType="submit"
                        type="primary"
                        disabledReason={isSubmitting ? `Saving url in progress` : undefined}
                        data-attr="url-save"
                    >
                        Save
                    </LemonButton>
                </div>
            </div>
        </Form>
    )
}