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.4 KB
Raw Blame
import { MakeLogicType, actions, afterMount, kea, listeners, path, props, reducers, selectors } from 'kea'
import { forms } from 'kea-forms'
import type { DeepPartial, DeepPartialMap, FieldName, ValidationErrorType } from 'kea-forms'
import { loaders } from 'kea-loaders'
import { encodeParams, router } from 'kea-router'

import { ApiError } from 'lib/api-error'
import { lemonToast } from 'lib/lemon-ui/LemonToast'
import { urls } from 'scenes/urls'

import type { DatasetItemCreateApi, DatasetReadApi } from '../generated/api.schemas'
import { aiObservabilityDatasetLogic } from './aiObservabilityDatasetLogic'
import { datasetsApi } from './datasetsApi'

export interface saveToDatasetButtonLogicProps {
    partialDatasetItem: Partial<DatasetItemCreateApi> | null
}

export const DATASETS_PER_PAGE = 100
export const RECENT_DATASETS_LIMIT = 3

export interface SearchFormValues {
    search: string
    datasetId: string | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface saveToDatasetButtonLogicValues {
    datasetStore: Record<string, DatasetReadApi[]>
    datasetStoreLoading: boolean
    datasets: DatasetReadApi[] | null
    dropdownVisible: boolean
    editMode: 'create' | 'edit'
    isLoadingDatasets: boolean
    isModalMounted: boolean
    isModalOpen: boolean
    isSearchFormSubmitting: boolean
    isSearchFormValid: boolean
    recentDatasetIds: string[]
    recentDatasets: DatasetReadApi[]
    recentDatasetsLoading: boolean
    searchForm: SearchFormValues
    searchFormAllErrors: Record<string, any>
    searchFormChanged: boolean
    searchFormErrors: DeepPartialMap<SearchFormValues, ValidationErrorType>
    searchFormHasErrors: boolean
    searchFormManualErrors: Record<string, any>
    searchFormTouched: boolean
    searchFormTouches: Record<string, boolean>
    searchFormValidationErrors: DeepPartialMap<SearchFormValues, ValidationErrorType>
    selectedDataset: DatasetReadApi | null
    showSearchFormErrors: boolean
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface saveToDatasetButtonLogicActions {
    closeItemModal: (itemCreated?: boolean) => {
        itemCreated: boolean
    }
    datasetItemCreated: (datasetId: string) => {
        datasetId: string
    }
    loadDatasets: (debounce?: boolean) => boolean
    loadDatasetsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadDatasetsSuccess: (
        datasetStore: {
            [x: string]: DatasetReadApi[]
        },
        payload?: boolean
    ) => {
        datasetStore: {
            [x: string]: DatasetReadApi[]
        }
        payload?: boolean
    }
    loadRecentDatasets: (debounce?: boolean) => boolean
    loadRecentDatasetsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadRecentDatasetsSuccess: (
        recentDatasets: DatasetReadApi[],
        payload?: boolean
    ) => {
        recentDatasets: DatasetReadApi[]
        payload?: boolean
    }
    resetSearchForm: (values?: SearchFormValues) => {
        values?: SearchFormValues
    }
    setDropdownVisible: (dropdownVisible: boolean) => {
        dropdownVisible: boolean
    }
    setEditMode: (editMode: 'create' | 'edit') => {
        editMode: 'create' | 'edit'
    }
    setIsModalOpen: (isModalOpen: boolean) => {
        isModalOpen: boolean
    }
    setRecentDatasetIds: (recentDatasetIds: string[]) => {
        recentDatasetIds: string[]
    }
    setRecentDatasets: (recentDatasets: DatasetReadApi[]) => {
        recentDatasets: DatasetReadApi[]
    }
    setSearchFormManualErrors: (errors: Record<string, any>) => {
        errors: Record<string, any>
    }
    setSearchFormValue: (
        key: FieldName,
        value: any
    ) => {
        name: FieldName
        value: any
    }
    setSearchFormValues: (values: DeepPartial<SearchFormValues>) => {
        values: DeepPartial<SearchFormValues>
    }
    setSelectedDataset: (dataset: DatasetReadApi | null) => {
        dataset: DatasetReadApi | null
    }
    submitSearchForm: () => {
        value: boolean
    }
    submitSearchFormFailure: (
        error: Error,
        errors: Record<string, any>
    ) => {
        error: Error
        errors: Record<string, any>
    }
    submitSearchFormRequest: (searchForm: SearchFormValues) => {
        searchForm: SearchFormValues
    }
    submitSearchFormSuccess: (searchForm: SearchFormValues) => {
        searchForm: SearchFormValues
    }
    touchSearchFormField: (key: string) => {
        key: string
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface saveToDatasetButtonLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        datasets: (
            datasetStore: Record<string, DatasetReadApi[]>,
            searchForm: SearchFormValues
        ) => DatasetReadApi[] | null
        isLoadingDatasets: (
            datasets: DatasetReadApi[] | null,
            datasetStoreLoading: boolean,
            recentDatasetsLoading: boolean
        ) => boolean
        isModalMounted: (editMode: 'create' | 'edit') => boolean
    }
}

export type saveToDatasetButtonLogicType = MakeLogicType<
    saveToDatasetButtonLogicValues,
    saveToDatasetButtonLogicActions,
    saveToDatasetButtonLogicProps,
    saveToDatasetButtonLogicMeta
>

export const saveToDatasetButtonLogic = kea<saveToDatasetButtonLogicType>([
    path(['scenes', 'ai-observability', 'saveToDatasetButtonLogic']),

    props({ partialDatasetItem: null } as saveToDatasetButtonLogicProps),

    actions({
        setIsModalOpen: (isModalOpen: boolean) => ({ isModalOpen }),
        setEditMode: (editMode: 'create' | 'edit') => ({ editMode }),
        setDropdownVisible: (dropdownVisible: boolean) => ({ dropdownVisible }),
        setSelectedDataset: (dataset: DatasetReadApi | null) => ({ dataset }),
        setRecentDatasetIds: (recentDatasetIds: string[]) => ({ recentDatasetIds }),
        setRecentDatasets: (recentDatasets: DatasetReadApi[]) => ({ recentDatasets }),
        closeItemModal: (itemCreated: boolean = false) => ({ itemCreated }),
        datasetItemCreated: (datasetId: string) => ({ datasetId }),
    }),

    reducers(() => ({
        isModalOpen: [
            false as boolean,
            {
                setIsModalOpen: (_, { isModalOpen }) => isModalOpen,
            },
        ],

        selectedDataset: [
            null as DatasetReadApi | null,
            {
                setSelectedDataset: (_, { dataset }) => dataset,
            },
        ],

        editMode: [
            'create' as 'create' | 'edit',
            {
                setEditMode: (_, { editMode }) => editMode,
                setIsModalOpen: (state, { isModalOpen }) => (isModalOpen ? state : 'create'),
            },
        ],

        dropdownVisible: [
            false as boolean,
            {
                setDropdownVisible: (_, { dropdownVisible }) => dropdownVisible,
            },
        ],

        recentDatasetIds: [
            [] as string[],
            { persist: true },
            {
                setRecentDatasetIds: (_, { recentDatasetIds }) => truncateRecentDatasets(recentDatasetIds),
            },
        ],

        recentDatasets: [
            [] as DatasetReadApi[],
            {
                setRecentDatasets: (_, { recentDatasets }) => truncateRecentDatasets(recentDatasets),
            },
        ],
    })),

    loaders(({ actions, values }) => ({
        datasetStore: [
            {} as Record<string, DatasetReadApi[]>,
            {
                loadDatasets: async (debounce: boolean = false, breakpoint) => {
                    if (debounce) {
                        await breakpoint(300)
                    }

                    const params = {
                        limit: DATASETS_PER_PAGE,
                        offset: 0,
                        search: values.searchForm.search || undefined,
                    }
                    const storageKey = getStorageKey(values.searchForm.search)
                    const response = await datasetsApi.listDatasets(params)
                    breakpoint()
                    return {
                        ...values.datasetStore,
                        [storageKey]: response.results,
                    }
                },
            },
        ],

        recentDatasets: [
            [] as DatasetReadApi[],
            {
                loadRecentDatasets: async (debounce: boolean = false, breakpoint) => {
                    if (debounce) {
                        await breakpoint(300)
                    }

                    if (values.recentDatasetIds.length === 0) {
                        return []
                    }

                    const response = await datasetsApi.listDatasets({
                        id__in: values.recentDatasetIds,
                        limit: RECENT_DATASETS_LIMIT,
                        offset: 0,
                    })
                    breakpoint()
                    const datasetsById = new Map(response.results.map((dataset) => [dataset.id, dataset]))
                    const recentDatasets = values.recentDatasetIds.flatMap((id) => {
                        const dataset = datasetsById.get(id)
                        return dataset && !dataset.archived ? [dataset] : []
                    })

                    if (recentDatasets.length !== values.recentDatasetIds.length) {
                        actions.setRecentDatasetIds(recentDatasets.map((dataset) => dataset.id))
                    }

                    return recentDatasets
                },
            },
        ],
    })),

    forms(({ asyncActions, actions, values, props }) => ({
        searchForm: {
            defaults: { search: '', datasetId: null } as SearchFormValues,

            submit: async ({ datasetId }) => {
                // Dataset is not selected. Submit from the search input.
                if (!datasetId) {
                    await asyncActions.loadDatasets(true)
                    return
                }

                // Close the dropdown.
                actions.setDropdownVisible(false)
                actions.resetSearchForm()

                // Find the selected dataset. Practically, this should always be found.
                const dataset = values.datasets?.find((dataset) => dataset.id === datasetId)
                if (!dataset) {
                    return
                }

                if (values.editMode === 'edit') {
                    // Open the modal.
                    actions.setSelectedDataset(dataset)
                    actions.setIsModalOpen(true)
                    return
                }

                try {
                    await datasetsApi.createItem({
                        dataset: datasetId,
                        client_item_id: props.partialDatasetItem?.client_item_id,
                        input: props.partialDatasetItem?.input ?? {},
                        expected_output: props.partialDatasetItem?.expected_output,
                        source_output: props.partialDatasetItem?.source_output,
                        metadata: props.partialDatasetItem?.metadata,
                        source_trace_id: props.partialDatasetItem?.source_trace_id,
                        source_event_id: props.partialDatasetItem?.source_event_id,
                        source_timestamp: props.partialDatasetItem?.source_timestamp,
                    })
                    actions.datasetItemCreated(datasetId)
                    lemonToast.success('Dataset item has been created successfully', {
                        button: {
                            label: 'View',
                            action: () => {
                                router.actions.push(urls.aiObservabilityDataset(datasetId))
                            },
                        },
                    })
                } catch (error) {
                    const detail = error instanceof ApiError ? error.detail : null
                    lemonToast.error(detail || "Couldn't add item to dataset. Try again.")
                }
            },
        },
    })),

    selectors({
        datasets: [
            (s) => [s.datasetStore, s.searchForm],
            (datasetStore: Record<string, DatasetReadApi[]>, searchForm: SearchFormValues): DatasetReadApi[] | null => {
                const storageKey = getStorageKey(searchForm.search)
                return datasetStore[storageKey] ?? null
            },
        ],

        isLoadingDatasets: [
            (s) => [s.datasets, s.datasetStoreLoading, s.recentDatasetsLoading],
            (
                datasets: DatasetReadApi[] | null,
                datasetStoreLoading: boolean,
                recentDatasetsLoading: boolean
            ): boolean => {
                return !datasets && (datasetStoreLoading || recentDatasetsLoading)
            },
        ],

        isModalMounted: [
            (s) => [s.editMode],
            (editMode: 'create' | 'edit'): boolean => {
                return editMode === 'edit'
            },
        ],
    }),

    listeners(({ actions, asyncActions, values }) => ({
        setIsModalOpen: () => {
            actions.setSearchFormValue('search', '')
        },

        closeItemModal: ({ itemCreated }) => {
            actions.setIsModalOpen(false)
            if (itemCreated && values.selectedDataset) {
                actions.datasetItemCreated(values.selectedDataset.id)
            }
        },

        datasetItemCreated: ({ datasetId }) => {
            aiObservabilityDatasetLogic.findMounted({ datasetId })?.actions.refreshAfterDatasetItemMutation()
        },

        setSearchFormValue: ({ name, value }) => {
            if (compareFieldName(name, 'search')) {
                asyncActions.loadDatasets(true)
            }

            if (compareFieldName(name, 'datasetId') && !values.recentDatasetIds.includes(value)) {
                const dataset = values.datasets?.find((dataset) => dataset.id === value)
                if (dataset) {
                    actions.setRecentDatasetIds([value, ...values.recentDatasetIds])
                    actions.setRecentDatasets([dataset, ...values.recentDatasets])
                }
            }
        },

        setDropdownVisible: ({ dropdownVisible }) => {
            if (dropdownVisible) {
                asyncActions.loadDatasets(true)
            } else {
                actions.setSearchFormValue('search', '')
            }
        },
    })),

    afterMount(({ actions, values }) => {
        if (!values.datasets?.length) {
            actions.loadDatasets(false)
            actions.loadRecentDatasets(false)
        }
    }),
])

export function getStorageKey(search: string): string {
    return encodeParams({
        limit: DATASETS_PER_PAGE,
        offset: 0,
        search,
    })
}

/**
 * Truncates the recent datasets to the first 3.
 * @param state - The current state.
 * @returns The updated state.
 */
export function truncateRecentDatasets<T>(state: T[]): T[] {
    return state.slice(0, RECENT_DATASETS_LIMIT)
}

/**
 * A field name from kea-forms is either a string or an array of strings. This function compares the name to the field name.
 * @param nameValue - The name to compare.
 * @param fieldName - The field name to compare.
 * @returns boolean
 */
export function compareFieldName(nameValue: string | number | (string | number)[], fieldName: string): boolean {
    if (Array.isArray(nameValue)) {
        return nameValue[0] === fieldName
    }
    return nameValue === fieldName
}