: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 { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { actionToUrl, router, urlToAction } from 'kea-router'
import { LemonTagType, PaginationManual } from '@posthog/lemon-ui'
import api, { CountedPaginatedResponse } from 'lib/api'
import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
import { parseNumericArrayFilter, parseTagsFilter, toParams } from 'lib/utils/url'
import { getFlagVariants } from 'scenes/experiments/utils'
import { FLAGS_PER_PAGE, type FeatureFlagsResult, featureFlagsLogic } from 'scenes/feature-flags/featureFlagsLogic'
import { projectLogic } from 'scenes/projectLogic'
import { teamLogic } from 'scenes/teamLogic'
import { urls } from 'scenes/urls'
import { userLogic } from 'scenes/userLogic'
import { SIDE_PANEL_CONTEXT_KEY, SidePanelSceneContext } from '~/layout/navigation-3000/sidepanel/types'
import {
ActivityScope,
Breadcrumb,
Experiment,
ExperimentStatus,
ExperimentVelocityStats,
ExperimentsTabs,
FeatureFlagType,
} from '~/types'
import type { AvailableFeature, UserType } from '~/types'
import type { TeamPublicType, TeamType } from '~/types'
export const EXPERIMENTS_PER_PAGE = 100
export interface ExperimentsResult extends CountedPaginatedResponse<Experiment> {
/* not in the API response */
filters?: ExperimentsFilters | null
}
export interface ExperimentsFilters {
search?: string
status?: ExperimentStatus | 'all'
created_by_id?: number[]
archived?: boolean
page?: number
order?: string
tags?: string[]
excluded_tags?: string[]
}
export interface FeatureFlagModalFilters {
active?: string
created_by_id?: number[]
search?: string
order?: string
page?: number
evaluation_runtime?: string
}
const DEFAULT_FILTERS: ExperimentsFilters = {
search: undefined,
status: 'all',
created_by_id: undefined,
archived: false,
page: 1,
order: undefined,
tags: undefined,
excluded_tags: undefined,
}
const DEFAULT_MODAL_FILTERS: FeatureFlagModalFilters = {
active: undefined,
created_by_id: undefined,
search: undefined,
order: undefined,
page: 1,
evaluation_runtime: undefined,
}
export function isSingleVariantShipped(experiment: Experiment): boolean {
const filters = experiment.feature_flag?.filters
return (
!!filters &&
experiment.feature_flag?.active !== false &&
Array.isArray(filters.groups?.[0]?.properties) &&
filters.groups?.[0]?.properties?.length === 0 &&
filters.groups?.[0]?.rollout_percentage === 100 &&
getFlagVariants(experiment.feature_flag).some(({ rollout_percentage }) => rollout_percentage === 100)
)
}
export function getShippedVariantKey(experiment: Experiment): string | null {
if (!isSingleVariantShipped(experiment)) {
return null
}
return (
getFlagVariants(experiment.feature_flag).find(({ rollout_percentage }) => rollout_percentage === 100)?.key ||
null
)
}
export function getExperimentStatusLabel(status: ExperimentStatus): string {
switch (status) {
case ExperimentStatus.Draft:
return 'Draft'
case ExperimentStatus.Running:
return 'Running'
case ExperimentStatus.Paused:
return 'Paused'
case ExperimentStatus.ExposureFrozen:
return 'Exposure frozen'
case ExperimentStatus.Stopped:
return 'Complete'
}
}
export function getExperimentStatusColor(status: ExperimentStatus): LemonTagType {
switch (status) {
case ExperimentStatus.Draft:
return 'default'
case ExperimentStatus.Running:
return 'success'
case ExperimentStatus.Paused:
return 'warning'
case ExperimentStatus.ExposureFrozen:
return 'highlight'
case ExperimentStatus.Stopped:
return 'completion'
}
}
function normalizeExperimentFilterStatus(status: string | undefined): ExperimentStatus | 'all' {
if (!status) {
return 'all'
}
const normalizedStatus = status.toLowerCase()
if (normalizedStatus === 'complete') {
return ExperimentStatus.Stopped
}
if (Object.values(ExperimentStatus).includes(normalizedStatus as ExperimentStatus)) {
return normalizedStatus as ExperimentStatus
}
return 'all'
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface experimentsLogicValues {
featureFlags: FeatureFlagsResult // featureFlagsLogic
currentProjectId: number | null // projectLogic
location: {
pathname: string
search: string
hash: string
} // router
currentTeam: TeamPublicType | TeamType | null // teamLogic
hasAvailableFeature: (feature: AvailableFeature, currentUsage?: number | undefined) => boolean // userLogic
user: UserType | null // userLogic
breadcrumbs: Breadcrumb[]
count: number
experiments: ExperimentsResult
experimentsLoading: boolean
experimentsStats: ExperimentVelocityStats
experimentsStatsLoading: boolean
featureFlagModalFeatureFlags: {
count: number
results: FeatureFlagType[]
}
featureFlagModalFeatureFlagsLoading: boolean
featureFlagModalFilters: FeatureFlagModalFilters
featureFlagModalPageFromURL: number
featureFlagModalPagination: PaginationManual
featureFlagModalParamsFromFilters: Record<string, any>
filters: ExperimentsFilters
hasLoadedExperiments: boolean
pagination: PaginationManual
paramsFromFilters: {
archived?: boolean | undefined
created_by_id?: number[] | undefined
excluded_tags?: string[] | undefined
limit: number
offset: number
order?: string | undefined
page?: number | undefined
search?: string | undefined
status?: ExperimentStatus | 'all' | undefined
tags?: string[] | undefined
}
sidePanelContext: SidePanelSceneContext
tab: ExperimentsTabs
unavailableFeatureFlagKeys: Set<string>
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface experimentsLogicActions {
reportExperimentsListViewed: (listView: {
archived: boolean
experimentsShown: number
hasSearch: boolean
page: number
statusFilter: string
}) => {
archived: boolean
experimentsShown: number
hasSearch: boolean
page: number
statusFilter: string
} // eventUsageLogic
reportExperimentsSettingsViewed: () => {
value: true
} // eventUsageLogic
loadCurrentTeamSuccess: (
currentTeam: TeamPublicType | null,
payload?: any
) => {
currentTeam: TeamPublicType | null
payload?: any
} // teamLogic
updateCurrentTeamSuccess: (
currentTeam: TeamPublicType | TeamType,
payload?: Partial<TeamType> | undefined
) => {
currentTeam: TeamPublicType | TeamType
payload?: Partial<TeamType>
} // teamLogic
addToExperiments: (experiment: Experiment) => Experiment
addToExperimentsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
addToExperimentsSuccess: (
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: Experiment[]
},
payload?: Experiment
) => {
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: Experiment[]
}
payload?: Experiment
}
archiveExperiment: ({ id, disableFeatureFlag }: { disableFeatureFlag: boolean; id: number }) => {
id: number
disableFeatureFlag: boolean
}
archiveExperimentFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
archiveExperimentSuccess: (
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: Experiment[]
},
payload?: {
id: number
disableFeatureFlag: boolean
}
) => {
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: Experiment[]
}
payload?: {
id: number
disableFeatureFlag: boolean
}
}
copyExperimentToProject: (payload: {
featureFlagKey?: string
id: number
name?: string
onSuccess?: () => void
targetProjectId: number
targetTeamId: number
}) => {
id: number
targetProjectId: number
targetTeamId: number
featureFlagKey?: string
name?: string
onSuccess?: () => void
}
copyExperimentToProjectFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
copyExperimentToProjectSuccess: (
experiments: ExperimentsResult,
payload?: {
id: number
targetProjectId: number
targetTeamId: number
featureFlagKey?: string
name?: string
onSuccess?: () => void
}
) => {
experiments: ExperimentsResult
payload?: {
id: number
targetProjectId: number
targetTeamId: number
featureFlagKey?: string
name?: string
onSuccess?: () => void
}
}
duplicateExperiment: (payload: { featureFlagKey?: string; id: number; name?: string }) => {
id: number
featureFlagKey?: string
name?: string
}
duplicateExperimentFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
duplicateExperimentSuccess: (
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: any[]
},
payload?: {
id: number
featureFlagKey?: string
name?: string
}
) => {
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: any[]
}
payload?: {
id: number
featureFlagKey?: string
name?: string
}
}
loadExperiments: (_: void) => void
loadExperimentsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
loadExperimentsStats: () => any
loadExperimentsStatsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
loadExperimentsStatsSuccess: (
experimentsStats: ExperimentVelocityStats,
payload?: any
) => {
experimentsStats: ExperimentVelocityStats
payload?: any
}
loadExperimentsSuccess: (
experiments: ExperimentsResult,
payload?: void
) => {
experiments: ExperimentsResult
payload?: void
}
loadFeatureFlagModalFeatureFlags: (_: void) => void
loadFeatureFlagModalFeatureFlagsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
loadFeatureFlagModalFeatureFlagsSuccess: (
featureFlagModalFeatureFlags: {
count: number
results: FeatureFlagType[]
},
payload?: void
) => {
featureFlagModalFeatureFlags: {
count: number
results: FeatureFlagType[]
}
payload?: void
}
resetFeatureFlagModalFilters: () => {
value: true
}
setExperimentsFilters: (
filters: Partial<ExperimentsFilters>,
replace?: boolean
) => {
filters: Partial<ExperimentsFilters>
replace: boolean | undefined
}
setExperimentsTab: (tabKey: ExperimentsTabs) => {
tabKey: ExperimentsTabs
}
setFeatureFlagModalFilters: (
filters: Partial<FeatureFlagModalFilters>,
replace?: boolean
) => {
filters: Partial<FeatureFlagModalFilters>
replace: boolean | undefined
}
unarchiveExperiment: (id: number) => number
unarchiveExperimentFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
unarchiveExperimentSuccess: (
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: Experiment[]
},
payload?: number
) => {
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: Experiment[]
}
payload?: number
}
updateExperiments: (experiment: Experiment) => Experiment
updateExperimentsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
updateExperimentsSuccess: (
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: Experiment[]
},
payload?: Experiment
) => {
experiments: {
count: number
filters?: ExperimentsFilters | null | undefined
next?: string | null | undefined
previous?: string | null | undefined
results: Experiment[]
}
payload?: Experiment
}
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface experimentsLogicMeta {
__keaTypeGenInternalSelectorTypes: {
count: (experiments: ExperimentsResult) => number
paramsFromFilters: (filters: ExperimentsFilters) => {
archived?: boolean | undefined
created_by_id?: number[] | undefined
excluded_tags?: string[] | undefined
limit: number
offset: number
order?: string | undefined
page?: number | undefined
search?: string | undefined
status?: ExperimentStatus | 'all' | undefined
tags?: string[] | undefined
}
featureFlagModalParamsFromFilters: (
featureFlagModalFilters: FeatureFlagModalFilters,
currentTeam: TeamPublicType | TeamType | null
) => Record<string, any>
featureFlagModalPageFromURL: (searchParams: Record<string, any>) => number
featureFlagModalPagination: (
featureFlagModalFilters: FeatureFlagModalFilters,
featureFlagModalFeatureFlags: {
count: number
results: FeatureFlagType[]
},
featureFlagModalPageFromURL: number
) => PaginationManual
pagination: (filters: ExperimentsFilters, count: number) => PaginationManual
unavailableFeatureFlagKeys: (featureFlags: FeatureFlagsResult, experiments: ExperimentsResult) => Set<string>
}
}
export type experimentsLogicType = MakeLogicType<
experimentsLogicValues,
experimentsLogicActions,
Record<string, any>,
experimentsLogicMeta
>
export const experimentsLogic = kea<experimentsLogicType>([
path(['scenes', 'experiments', 'experimentsLogic']),
connect(() => ({
values: [
projectLogic,
['currentProjectId'],
userLogic,
['user', 'hasAvailableFeature'],
featureFlagsLogic,
['featureFlags'],
router,
['location'],
teamLogic,
['currentTeam'],
],
actions: [
teamLogic,
['loadCurrentTeamSuccess', 'updateCurrentTeamSuccess'],
eventUsageLogic,
['reportExperimentsListViewed', 'reportExperimentsSettingsViewed'],
],
})),
actions({
setExperimentsTab: (tabKey: ExperimentsTabs) => ({ tabKey }),
setExperimentsFilters: (filters: Partial<ExperimentsFilters>, replace?: boolean) => ({ filters, replace }),
setFeatureFlagModalFilters: (filters: Partial<FeatureFlagModalFilters>, replace?: boolean) => ({
filters,
replace,
}),
resetFeatureFlagModalFilters: true,
}),
reducers({
filters: [
DEFAULT_FILTERS,
{
setExperimentsFilters: (state, { filters, replace }) => {
if (replace) {
return { ...filters }
}
return { ...state, ...filters }
},
},
],
featureFlagModalFilters: [
DEFAULT_MODAL_FILTERS,
{
setFeatureFlagModalFilters: (state, { filters, replace }) => {
if (replace) {
return { ...filters }
}
return { ...state, ...filters }
},
resetFeatureFlagModalFilters: () => DEFAULT_MODAL_FILTERS,
},
],
tab: [
ExperimentsTabs.All as ExperimentsTabs,
{
setExperimentsTab: (state, { tabKey }) => tabKey ?? state,
},
],
hasLoadedExperiments: [
false,
{
loadExperimentsSuccess: () => true,
loadExperimentsFailure: () => true,
},
],
}),
listeners(({ actions, values }) => ({
setExperimentsTab: ({ tabKey }) => {
if (tabKey === ExperimentsTabs.Settings) {
actions.reportExperimentsSettingsViewed()
}
},
setExperimentsFilters: async (_, breakpoint) => {
// Only debounce after the first load — the debounce is for search input,
// but the initial load from urlToAction should fire immediately.
if (values.hasLoadedExperiments || values.experimentsLoading) {
await breakpoint(300)
}
actions.loadExperiments()
},
setFeatureFlagModalFilters: async (_, breakpoint) => {
await breakpoint(300)
actions.loadFeatureFlagModalFeatureFlags()
},
resetFeatureFlagModalFilters: () => {
actions.loadFeatureFlagModalFeatureFlags()
},
loadExperimentsSuccess: ({ experiments }) => {
// The list also loads behind the other tabs of the scene, where nobody sees it.
if (values.tab === ExperimentsTabs.All) {
const filters = experiments.filters ?? {}
actions.reportExperimentsListViewed({
experimentsShown: experiments.results.length,
statusFilter: filters.status ?? 'all',
page: filters.page ?? 1,
hasSearch: !!filters.search,
archived: !!filters.archived,
})
}
},
loadCurrentTeamSuccess: () => {
if (values.featureFlagModalFeatureFlags.results.length > 0) {
actions.loadFeatureFlagModalFeatureFlags()
}
},
updateCurrentTeamSuccess: () => {
if (values.featureFlagModalFeatureFlags.results.length > 0) {
actions.loadFeatureFlagModalFeatureFlags()
}
},
})),
loaders(({ values }) => ({
experiments: [
{ results: [], count: 0, filters: DEFAULT_FILTERS, offset: 0 } as ExperimentsResult,
{
loadExperiments: async (_: void, breakpoint) => {
// A filter change during the request must not relabel this response.
const filters = values.filters
// 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.currentProjectId}/experiments?${toParams(values.paramsFromFilters)}`
)
// Discard stale responses that resolve after a newer search has fired
breakpoint()
return {
...response,
offset: values.paramsFromFilters.offset,
filters,
}
},
archiveExperiment: async ({ id, disableFeatureFlag }: { id: number; disableFeatureFlag: boolean }) => {
// nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsArchiveCreate() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
await api.create(`api/projects/${values.currentProjectId}/experiments/${id}/archive`, {
disable_feature_flag: disableFeatureFlag,
})
lemonToast.info('Experiment archived')
return {
...values.experiments,
results: values.experiments.results.filter((experiment) => experiment.id !== id),
count: values.experiments.count - 1,
}
},
unarchiveExperiment: async (id: number) => {
// nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsUnarchiveCreate() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
await api.create(`api/projects/${values.currentProjectId}/experiments/${id}/unarchive`)
lemonToast.info('Experiment unarchived')
return {
...values.experiments,
results: values.experiments.results.filter((experiment) => experiment.id !== id),
count: values.experiments.count - 1,
}
},
duplicateExperiment: async (payload: { id: number; featureFlagKey?: string; name?: string }) => {
const data: Record<string, string> = {}
if (payload.featureFlagKey) {
data.feature_flag_key = payload.featureFlagKey
}
if (payload.name) {
data.name = payload.name
}
// nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsDuplicateCreate() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
const duplicatedExperiment = await api.create(
`api/projects/${values.currentProjectId}/experiments/${payload.id}/duplicate`,
data
)
lemonToast.success('Experiment duplicated successfully')
// Navigate to the newly created experiment
router.actions.push(urls.experiment(duplicatedExperiment.id))
return {
...values.experiments,
results: [duplicatedExperiment, ...values.experiments.results],
count: values.experiments.count + 1,
}
},
copyExperimentToProject: async (payload: {
id: number
targetProjectId: number
targetTeamId: number
featureFlagKey?: string
name?: string
onSuccess?: () => void
}) => {
const data: Record<string, any> = { target_team_id: payload.targetTeamId }
if (payload.featureFlagKey) {
data.feature_flag_key = payload.featureFlagKey
}
if (payload.name) {
data.name = payload.name
}
// nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsCopyToProjectCreate() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
const newExperiment = await api.create(
`api/projects/${values.currentProjectId}/experiments/${payload.id}/copy_to_project`,
data
)
lemonToast.success('Experiment copied to project', {
button: {
label: 'Go to experiment',
action: () => {
window.location.href = urls.project(
payload.targetProjectId,
urls.experiment(newExperiment.id)
)
},
},
})
payload.onSuccess?.()
return values.experiments
},
addToExperiments: (experiment: Experiment) => {
return {
...values.experiments,
results: [...values.experiments.results, experiment],
count: values.experiments.count + 1,
}
},
updateExperiments: (experiment: Experiment) => {
return {
...values.experiments,
results: values.experiments.results.map((exp) => (exp.id === experiment.id ? experiment : exp)),
count: values.experiments.count,
}
},
},
],
featureFlagModalFeatureFlags: [
{ results: [], count: 0 } as { results: FeatureFlagType[]; count: number },
{
loadFeatureFlagModalFeatureFlags: async (_: void, breakpoint) => {
// nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. Use featureFlagsList() from 'products/feature_flags/frontend/generated/api' instead.
const response = await api.get(
`api/projects/${values.currentProjectId}/feature_flags/?${toParams({
...values.featureFlagModalParamsFromFilters,
eligible_for_experiment: true,
})}`
)
// Discard stale responses that resolve after a newer search has fired
breakpoint()
return response
},
},
],
experimentsStats: [
{
launched_last_30d: 0,
launched_previous_30d: 0,
percent_change: 0,
active_experiments: 0,
completed_last_30d: 0,
} as ExperimentVelocityStats,
{
loadExperimentsStats: async () => {
// nosemgrep: prefer-codegen-api -- Legacy raw API call with a hand-written URL and an unchecked response type. experimentsStatsRetrieve() from 'products/experiments/frontend/generated/api' serves this route, but its generated types do not describe this call yet, so fix the endpoint's OpenAPI schema first.
const response = await api.get(`api/projects/${values.currentProjectId}/experiments/stats/`)
return response
},
},
],
})),
selectors(() => ({
count: [(selectors) => [selectors.experiments], (experiments: ExperimentsResult) => experiments.count],
paramsFromFilters: [
(s) => [s.filters],
(filters: ExperimentsFilters) => ({
...filters,
limit: EXPERIMENTS_PER_PAGE,
offset: filters.page ? (filters.page - 1) * EXPERIMENTS_PER_PAGE : 0,
}),
],
featureFlagModalParamsFromFilters: [
(s) => [s.featureFlagModalFilters, s.currentTeam],
(
filters: FeatureFlagModalFilters,
currentTeam: null | import('~/types').TeamPublicType | import('~/types').TeamType
) => {
const params: Record<string, any> = {
...filters,
limit: FLAGS_PER_PAGE,
offset: filters.page ? (filters.page - 1) * FLAGS_PER_PAGE : 0,
}
// Add evaluation contexts filter if required by team
if (currentTeam?.require_evaluation_contexts) {
params.has_evaluation_contexts = true
}
return params
},
],
featureFlagModalPageFromURL: [
() => [router.selectors.searchParams],
(searchParams: Record<string, any>) => {
return parseInt(searchParams['ff_page']) || 1
},
],
featureFlagModalPagination: [
(s) => [s.featureFlagModalFilters, s.featureFlagModalFeatureFlags, s.featureFlagModalPageFromURL],
(
filters: FeatureFlagModalFilters,
featureFlags: {
count: number
results: FeatureFlagType[]
},
urlPage: number
): PaginationManual => {
const currentPage = Math.max(filters.page || 1, urlPage)
const hasNextPage = featureFlags.count > currentPage * FLAGS_PER_PAGE
const hasPreviousPage = currentPage > 1
const needsPagination = featureFlags.count > FLAGS_PER_PAGE
return {
controlled: true,
pageSize: FLAGS_PER_PAGE,
currentPage,
entryCount: featureFlags.count,
onForward:
needsPagination && hasNextPage
? () => {
experimentsLogic.actions.setFeatureFlagModalFilters({ page: currentPage + 1 })
}
: undefined,
onBackward:
needsPagination && hasPreviousPage
? () => {
experimentsLogic.actions.setFeatureFlagModalFilters({
page: Math.max(1, currentPage - 1),
})
}
: undefined,
}
},
],
pagination: [
(s) => [s.filters, s.count],
(filters: ExperimentsFilters, count: number): PaginationManual => {
return {
controlled: true,
pageSize: EXPERIMENTS_PER_PAGE,
currentPage: filters.page || 1,
entryCount: count,
}
},
],
// TRICKY: we do not load all feature flags here, just the latest ones.
unavailableFeatureFlagKeys: [
(s) => [featureFlagsLogic.selectors.featureFlags, s.experiments],
(featureFlags: FeatureFlagsResult, experiments: ExperimentsResult) => {
return new Set([
...featureFlags.results.map((flag) => flag.key),
...experiments.results.map((experiment) => experiment.feature_flag_key),
])
},
],
})),
selectors({
breadcrumbs: [
() => [],
(): Breadcrumb[] => [
{
key: 'experiments',
name: 'Experiments',
iconType: 'experiment',
},
],
],
[SIDE_PANEL_CONTEXT_KEY]: [
() => [],
(): SidePanelSceneContext => ({
activity_scope: ActivityScope.EXPERIMENT,
}),
],
}),
afterMount(({ actions, values }) => {
actions.loadExperimentsStats()
// Sync modal page with URL on mount. Eligible flags themselves are loaded lazily when the
// "link existing flag" modal sets or resets its filters, not on every list mount.
const urlPage = values.featureFlagModalPageFromURL
if (urlPage !== 1) {
actions.setFeatureFlagModalFilters({ page: urlPage })
}
}),
actionToUrl(({ values }) => {
const changeUrl = ():
| [
string,
Record<string, any>,
Record<string, any>,
{
replace: boolean
},
]
| void => {
const searchParams: Record<string, string | number | boolean | number[] | string[]> = {
...values.filters,
}
if (values.tab !== ExperimentsTabs.All) {
searchParams['tab'] = values.tab
}
// Preserve the activity deep-link param only when on the history tab
const currentActivity = router.values.searchParams['activity']
if (currentActivity && values.tab === ExperimentsTabs.History) {
searchParams['activity'] = currentActivity
}
return [router.values.location.pathname, searchParams, router.values.hashParams, { replace: true }]
}
const changeFeatureFlagModalUrl = ():
| [
string,
Record<string, any>,
Record<string, any>,
{
replace: boolean
},
]
| void => {
const searchParams: Record<string, string | number | boolean | number[] | string[]> = {
...values.filters,
}
if (values.tab !== ExperimentsTabs.All) {
searchParams['tab'] = values.tab
}
// Add feature flag modal page to URL if not page 1
const modalPage = values.featureFlagModalFilters.page || 1
if (modalPage !== 1) {
searchParams['ff_page'] = modalPage
}
return [router.values.location.pathname, searchParams, router.values.hashParams, { replace: true }]
}
return {
setExperimentsFilters: changeUrl,
setExperimentsTab: changeUrl,
setFeatureFlagModalFilters: changeFeatureFlagModalUrl,
resetFeatureFlagModalFilters: changeFeatureFlagModalUrl,
}
}),
urlToAction(({ actions, values }) => ({
[urls.experiments()]: async (_, searchParams) => {
const tabInURL = searchParams['tab']
if (!tabInURL) {
if (values.tab !== ExperimentsTabs.All) {
actions.setExperimentsTab(ExperimentsTabs.All)
}
} else if (tabInURL !== values.tab) {
actions.setExperimentsTab(tabInURL)
}
const { page, search, status, created_by_id, order, archived, tags, excluded_tags } = searchParams
const pageFiltersFromUrl: Partial<ExperimentsFilters> = {
search,
created_by_id: parseNumericArrayFilter(created_by_id),
order,
tags: parseTagsFilter(tags),
excluded_tags: parseTagsFilter(excluded_tags),
}
pageFiltersFromUrl.status = normalizeExperimentFilterStatus(status)
pageFiltersFromUrl.page = page !== undefined ? parseInt(page) : 1
pageFiltersFromUrl.archived = String(archived) === 'true'
actions.setExperimentsFilters({ ...DEFAULT_FILTERS, ...pageFiltersFromUrl })
},
})),
])