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.

6.1 KB
Raw Blame
import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'

import api, { CountedPaginatedResponse } from 'lib/api'
import { Sorting } from 'lib/lemon-ui/LemonTable'
import { objectsEqual } from 'lib/utils/objects'
import { toParams } from 'lib/utils/url'
import { teamLogic } from 'scenes/teamLogic'

import { Experiment } from '~/types'

export interface ExperimentsModalFilters {
    search?: string
    page?: number
    order?: string
}

const EXPERIMENTS_PER_PAGE = 10

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface addExperimentsToNotebookModalLogicValues {
    currentTeamId: number | null // teamLogic
    count: number
    experiments: CountedPaginatedResponse<Experiment>
    experimentsLoading: boolean
    experimentsPerPage: number
    filters: ExperimentsModalFilters
    modalPage: number
    rawModalFilters: ExperimentsModalFilters
    sorting: Sorting | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface addExperimentsToNotebookModalLogicActions {
    closeModal: () => {
        value: true
    }
    loadExperiments: () => {
        value: true
    }
    loadExperimentsFailure: (
        error: string,
        errorObject?: any
    ) => {
        error: string
        errorObject?: any
    }
    loadExperimentsSuccess: (
        experiments: CountedPaginatedResponse<Experiment>,
        payload?: {
            value: true
        }
    ) => {
        experiments: CountedPaginatedResponse<Experiment>
        payload?: {
            value: true
        }
    }
    setModalFilters: (
        filters: Partial<ExperimentsModalFilters>,
        merge?: boolean
    ) => {
        filters: Partial<ExperimentsModalFilters>
        merge: boolean
    }
    setModalPage: (page: number) => {
        page: number
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface addExperimentsToNotebookModalLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        filters: (rawModalFilters: ExperimentsModalFilters) => ExperimentsModalFilters
        count: (experiments: CountedPaginatedResponse<Experiment>) => number
        modalPage: (filters: ExperimentsModalFilters) => number
        sorting: (filters: ExperimentsModalFilters) => Sorting | null
    }
}

export type addExperimentsToNotebookModalLogicType = MakeLogicType<
    addExperimentsToNotebookModalLogicValues,
    addExperimentsToNotebookModalLogicActions,
    Record<string, any>,
    addExperimentsToNotebookModalLogicMeta
>

export const addExperimentsToNotebookModalLogic = kea<addExperimentsToNotebookModalLogicType>([
    path(['scenes', 'notebooks', 'AddExperimentsToNotebookModal', 'addExperimentsToNotebookModalLogic']),
    connect(() => ({
        values: [teamLogic, ['currentTeamId']],
    })),
    actions({
        closeModal: true,
        setModalFilters: (filters: Partial<ExperimentsModalFilters>, merge: boolean = true) => ({ filters, merge }),
        setModalPage: (page: number) => ({ page }),
        loadExperiments: true,
    }),
    loaders(({ values }) => ({
        experiments: {
            __default: { results: [] as Experiment[], count: 0 } as CountedPaginatedResponse<Experiment>,
            loadExperiments: async (_, breakpoint) => {
                await breakpoint(300)

                const { order, page = 1, search } = values.filters
                const perPage = EXPERIMENTS_PER_PAGE

                const params: Record<string, any> = {
                    limit: perPage,
                    offset: Math.max(0, (page - 1) * perPage),
                }

                if (search) {
                    params.search = search
                }
                if (order) {
                    params.order = order
                }

                // nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. Use experimentsList() from 'products/experiments/frontend/generated/api' instead.
                const response = await api.get(`api/projects/${values.currentTeamId}/experiments/?${toParams(params)}`)

                breakpoint()
                return response
            },
        },
    })),
    reducers({
        rawModalFilters: [
            { page: 1, order: '-created_at' } as ExperimentsModalFilters,
            {
                setModalFilters: (state, { filters, merge }) => ({
                    ...(merge ? state : {}),
                    ...filters,
                    ...('page' in filters ? {} : { page: 1 }),
                }),
                closeModal: () => ({ page: 1, order: '-created_at' }),
            },
        ],
    }),
    selectors({
        filters: [
            (s) => [s.rawModalFilters],
            (rawModalFilters: ExperimentsModalFilters): ExperimentsModalFilters => ({
                page: 1,
                order: '-created_at',
                ...rawModalFilters,
            }),
        ],
        experimentsPerPage: [() => [], (): number => EXPERIMENTS_PER_PAGE],
        count: [(s) => [s.experiments], (experiments: CountedPaginatedResponse<Experiment>) => experiments.count],
        modalPage: [(s) => [s.filters], (filters: ExperimentsModalFilters) => filters.page || 1],
        sorting: [
            (s) => [s.filters],
            (filters: ExperimentsModalFilters): Sorting | null =>
                filters.order
                    ? filters.order.startsWith('-')
                        ? { columnKey: filters.order.slice(1), order: -1 }
                        : { columnKey: filters.order, order: 1 }
                    : null,
        ],
    }),
    listeners(({ actions, values, selectors, props }) => ({
        setModalPage: ({ page }) => {
            actions.setModalFilters({ page }, true)
        },
        setModalFilters: (_, __, ___, previousState) => {
            const oldFilters = selectors.filters(previousState, props)
            const newFilters = values.filters

            if (!objectsEqual(oldFilters, newFilters)) {
                actions.loadExperiments()
            }
        },
    })),
])