: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, connect, kea, listeners, path, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { actionToUrl, router, urlToAction } from 'kea-router'
import posthog from 'posthog-js'
import api from 'lib/api'
import { FEATURE_FLAGS } from 'lib/constants'
import { FeatureFlagsSet, featureFlagLogic } from 'lib/logic/featureFlagLogic'
import { removeProjectIdIfPresent } from 'lib/utils/kea-router'
import { teamLogic } from 'scenes/teamLogic'
import { AnalyticsListUrlParams, urls } from 'scenes/urls'
import { userLogic } from 'scenes/userLogic'
import { projectTreeDataLogic } from '~/layout/panel-layout/ProjectTree/projectTreeDataLogic'
import { isPathUnder, joinPath, splitPath } from '~/layout/panel-layout/ProjectTree/utils'
import { todayAnalyticsLogic } from '~/layout/today/todayAnalyticsLogic'
import { uiCustomizationLogic } from '~/layout/uiCustomizationLogic'
import {
AnalyticsListDisplayConfiguration,
FileSystemEntry,
UserUIConfiguration,
} from '~/queries/schema/schema-general'
import type { UserBasicType, UserType } from '~/types'
import {
ANALYTICS_FEED_PAGE_SIZE,
AnalyticsFeed,
AnalyticsFeedQuery,
AnalyticsSourceState,
analyticsFeedTypes,
isAnalyticsOrderBy,
analyticsSourceKey,
} from './analyticsFeed'
import { analyticsFeedLogic, selectAnalyticsFeed } from './analyticsFeedLogic'
import { analyticsShareLogic } from './analyticsShareLogic'
import {
ANALYTICS_FILE_SYSTEM_TYPES,
AnalyticsItem,
AnalyticsType,
fileSystemBaseType,
fileSystemEntryName,
fileSystemEntryToAnalytics,
isAnalyticsType,
} from './analyticsUtils'
export const ANALYTICS_PREFETCH_COUNT = ANALYTICS_FEED_PAGE_SIZE
// A folder lists its direct children in one request. Deeper folders are opened by drilling in.
const FOLDER_PAGE_SIZE = ANALYTICS_FEED_PAGE_SIZE
export const DEFAULT_ANALYTICS_SORT: NonNullable<AnalyticsListDisplayConfiguration['default_sort']> = '-last_viewed_at'
export interface AnalyticsListFilters {
/** Empty means every type. */
types: AnalyticsType[]
orderBy?: AnalyticsFeedQuery['orderBy']
search: string
/** User uuids; empty means anyone. */
createdBy: string[]
/** A file system folder path to browse, '' for the project root, or null for the whole project. */
folder: string | null
tags: string[]
}
export const DEFAULT_ANALYTICS_LIST_FILTERS: AnalyticsListFilters = {
types: [],
search: '',
createdBy: [],
folder: null,
tags: [],
}
export type AnalyticsListMode = 'feed' | 'folder'
/** `all` lists what the project shares; `mine` lists everything the person created, shared or not. */
export type AnalyticsListScope = 'all' | 'mine'
export interface FolderContents {
/** The folder these rows belong to, so a failed or slow load never shows another folder's rows. */
folder: string
hasMore: boolean
entries: FileSystemEntry[]
users: UserBasicType[]
}
export interface FolderRow {
path: string
name: string
entry?: FileSystemEntry
createdAt?: string | null
createdBy?: AnalyticsItem['createdBy']
}
export type AnalyticsListState = 'loading' | 'error' | 'empty' | 'no-matches' | 'ready'
function stringList(value: unknown): string[] {
if (typeof value === 'string') {
return value ? [value] : []
}
return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : []
}
/** The router reads a value that looks like a number or a boolean as one, so text goes back to a string. */
function urlParamToString(value: unknown): string {
return `${value ?? ''}`
}
export function analyticsListFiltersFromUrl(params: Record<string, any>): AnalyticsListFilters {
const tags = Array.isArray(params.tags)
? params.tags.filter((tag: unknown): tag is string => typeof tag === 'string')
: []
return {
// A link can carry one type as plain text, such as the canvas product's `type=canvas`.
types: stringList(params.type).filter(isAnalyticsType),
orderBy: isAnalyticsOrderBy(params.orderBy) ? params.orderBy : undefined,
search: urlParamToString(params.search),
createdBy: stringList(params.createdBy),
folder: params.folder === undefined || params.folder === null ? null : urlParamToString(params.folder),
tags,
}
}
export function analyticsListUrlParams(filters: AnalyticsListFilters): AnalyticsListUrlParams {
return {
orderBy: filters.orderBy,
type: filters.types.length ? filters.types : undefined,
search: filters.search || undefined,
createdBy: filters.createdBy.length ? filters.createdBy : undefined,
folder: filters.folder ?? undefined,
tags: filters.tags.length ? filters.tags : undefined,
}
}
export function analyticsListFiltersActive(filters: AnalyticsListFilters): boolean {
return (
filters.types.length > 0 || !!filters.search.trim() || filters.createdBy.length > 0 || filters.tags.length > 0
)
}
/** Narrows rows the server did not filter: folder contents come back whole. */
export function filterAnalytics(
items: AnalyticsItem[],
filters: AnalyticsListFilters,
insightsHidden = false
): AnalyticsItem[] {
const needle = filters.search.trim().toLowerCase()
const createdBy = filters.createdBy
return items.filter(
(item) =>
filters.tags.every((tag) => item.tags.includes(tag)) &&
(filters.types.length ? filters.types.includes(item.type) : !insightsHidden || item.type !== 'insight') &&
(!needle || item.name.toLowerCase().includes(needle)) &&
(!createdBy.length || (!!item.createdBy && createdBy.includes(item.createdBy.uuid)))
)
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface analyticsListLogicValues {
sources: Record<string, AnalyticsSourceState> // analyticsFeedLogic
featureFlags: FeatureFlagsSet // featureFlagLogic
currentTeamId: number | null // teamLogic
uiConfiguration: UserUIConfiguration | null // uiCustomizationLogic
user: UserType | null // userLogic
creators: string[]
currentFeed: AnalyticsFeed
currentUserUuid: string | null
defaultSort: NonNullable<AnalyticsListDisplayConfiguration['default_sort']>
displayConfiguration: AnalyticsListDisplayConfiguration
failedTypes: AnalyticsFeed['failedTypes']
feed: AnalyticsFeed
feedQuery: AnalyticsFeedQuery
feedSearch: string
feedStale: boolean
filters: AnalyticsListFilters
filtersActive: boolean
folderBreadcrumbs: FolderRow[]
folderContents: FolderContents | null
folderContentsLoading: boolean
folderFailed: boolean
hasMore: boolean
insightsHidden: boolean
items: AnalyticsItem[]
listState: AnalyticsListState
loadedCount: number
loading: boolean
mode: AnalyticsListMode
narrowingFiltersActive: boolean
scope: AnalyticsListScope
searchInput: string
shownQuery: AnalyticsFeedQuery | null
subfolders: FolderRow[]
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface analyticsListLogicActions {
ensureFeed: (
query: AnalyticsFeedQuery,
count: number
) => {
count: number
query: AnalyticsFeedQuery
} // analyticsFeedLogic
refreshFeed: (query: AnalyticsFeedQuery) => {
query: AnalyticsFeedQuery
} // analyticsFeedLogic
sourceRefreshed: (
key: string,
generation: number,
page: null | import('./analyticsFeed').AnalyticsSourcePage
) => {
generation: number
key: string
page: null | import('./analyticsFeed').AnalyticsSourcePage
} // analyticsFeedLogic
shareToSpaceDone: () => {
value: true
} // analyticsShareLogic
deleteSavedItem: (savedItem: FileSystemEntry) => {
savedItem: FileSystemEntry
} // projectTreeDataLogic
movesSettled: (moved: import('~/layout/panel-layout/ProjectTree/projectTreeDataLogic').MovedItem[]) => {
moved: import('~/layout/panel-layout/ProjectTree/projectTreeDataLogic').MovedItem[]
} // projectTreeDataLogic
folderCreated: () => {
value: true
} // todayAnalyticsLogic
updateUiConfiguration: (
configuration: UserUIConfiguration,
successCallback?: (() => void) | undefined,
failureCallback?: (() => void) | undefined
) => {
configuration: UserUIConfiguration
failureCallback: (() => void) | undefined
successCallback: (() => void) | undefined
} // uiCustomizationLogic
clearFilters: () => {
value: true
}
clearNarrowingFilters: () => {
value: true
}
loadFolderContents: (_: void) => void
loadFolderContentsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
loadFolderContentsSuccess: (
folderContents: {
entries: FileSystemEntry[]
folder: string
hasMore: boolean
users: UserBasicType[]
} | null,
payload?: void
) => {
folderContents: {
entries: FileSystemEntry[]
folder: string
hasMore: boolean
users: UserBasicType[]
} | null
payload?: void
}
loadList: () => {
value: true
}
loadMore: () => {
value: true
}
loadMoreFolderContents: (_: void) => void
loadMoreFolderContentsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
loadMoreFolderContentsSuccess: (
folderContents: FolderContents | null,
payload?: void
) => {
folderContents: FolderContents | null
payload?: void
}
setDefaultSort: (orderBy: NonNullable<AnalyticsListDisplayConfiguration['default_sort']>) => {
orderBy: NonNullable<'-created_at' | '-last_viewed_at' | undefined>
}
setFeedSearch: (search: string) => {
search: string
}
setFilters: (filters: Partial<AnalyticsListFilters>) => {
filters: Partial<AnalyticsListFilters>
}
setFiltersFromUrl: (filters: AnalyticsListFilters) => {
filters: AnalyticsListFilters
}
setInsightsHidden: (hidden: boolean) => {
hidden: boolean
}
setScope: (scope: AnalyticsListScope) => {
scope: AnalyticsListScope
}
setSearchInput: (search: string) => {
search: string
}
setShownQuery: (query: AnalyticsFeedQuery) => {
query: AnalyticsFeedQuery
}
storeFilters: (filters: AnalyticsListFilters) => {
filters: AnalyticsListFilters
}
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface analyticsListLogicMeta {
__keaTypeGenInternalSelectorTypes: {
mode: (filters: AnalyticsListFilters) => AnalyticsListMode
filtersActive: (filters: AnalyticsListFilters) => boolean
narrowingFiltersActive: (filters: AnalyticsListFilters, scope: AnalyticsListScope) => boolean
currentUserUuid: (user: UserType | null) => string | null
creators: (filters: AnalyticsListFilters, currentUserUuid: string | null, scope: AnalyticsListScope) => string[]
displayConfiguration: (uiConfiguration: UserUIConfiguration | null) => AnalyticsListDisplayConfiguration
insightsHidden: (displayConfiguration: AnalyticsListDisplayConfiguration) => boolean
defaultSort: (
displayConfiguration: AnalyticsListDisplayConfiguration
) => NonNullable<AnalyticsListDisplayConfiguration['default_sort']>
feedQuery: (
filters: AnalyticsListFilters,
feedSearch: string,
creators: string[],
currentUserUuid: string | null,
defaultSort: NonNullable<'-created_at' | '-last_viewed_at' | undefined>,
insightsHidden: boolean
) => AnalyticsFeedQuery
currentFeed: (
sources: Record<string, AnalyticsSourceState>,
currentTeamId: number | null,
feedQuery: AnalyticsFeedQuery
) => AnalyticsFeed
feed: (
currentFeed: AnalyticsFeed,
sources: Record<string, AnalyticsSourceState>,
currentTeamId: number | null,
shownQuery: AnalyticsFeedQuery | null
) => AnalyticsFeed
feedStale: (currentFeed: AnalyticsFeed, feed: AnalyticsFeed) => boolean
items: (
mode: AnalyticsListMode,
feed: AnalyticsFeed,
folderContents: FolderContents | null,
filters: AnalyticsListFilters,
insightsHidden: boolean
) => AnalyticsItem[]
subfolders: (
mode: AnalyticsListMode,
folderContents: FolderContents | null,
filters: AnalyticsListFilters
) => FolderRow[]
folderBreadcrumbs: (filters: AnalyticsListFilters) => FolderRow[]
loading: (mode: AnalyticsListMode, feed: AnalyticsFeed, folderContentsLoading: boolean) => boolean
loadedCount: (
mode: AnalyticsListMode,
sources: Record<string, AnalyticsSourceState>,
feedQuery: AnalyticsFeedQuery,
currentTeamId: number | null,
folderContents: FolderContents | null
) => number
hasMore: (
mode: AnalyticsListMode,
feed: AnalyticsFeed,
folderContents: FolderContents | null,
filters: AnalyticsListFilters
) => boolean
failedTypes: (mode: AnalyticsListMode, feed: AnalyticsFeed) => AnalyticsFeed['failedTypes']
listState: (
mode: AnalyticsListMode,
feed: AnalyticsFeed,
folderContents: FolderContents | null,
folderFailed: boolean,
items: AnalyticsItem[],
subfolders: FolderRow[],
filtersActive: boolean
) => AnalyticsListState
}
}
export type analyticsListLogicType = MakeLogicType<
analyticsListLogicValues,
analyticsListLogicActions,
Record<string, any>,
analyticsListLogicMeta
>
export const analyticsListLogic = kea<analyticsListLogicType>([
path(['scenes', 'analytics', 'analyticsListLogic']),
connect(() => ({
values: [
featureFlagLogic,
['featureFlags'],
teamLogic,
['currentTeamId'],
userLogic,
['user'],
analyticsFeedLogic,
['sources'],
uiCustomizationLogic,
['uiConfiguration'],
],
actions: [
uiCustomizationLogic,
['updateUiConfiguration'],
analyticsFeedLogic,
['ensureFeed', 'refreshFeed', 'sourceRefreshed'],
analyticsShareLogic,
['shareToSpaceDone'],
todayAnalyticsLogic,
['folderCreated'],
projectTreeDataLogic,
['movesSettled', 'deleteSavedItem'],
],
})),
actions({
setScope: (scope: AnalyticsListScope) => ({ scope }),
setInsightsHidden: (hidden: boolean) => ({ hidden }),
setFilters: (filters: Partial<AnalyticsListFilters>) => ({ filters }),
setDefaultSort: (orderBy: NonNullable<AnalyticsListDisplayConfiguration['default_sort']>) => ({ orderBy }),
setFiltersFromUrl: (filters: AnalyticsListFilters) => ({ filters }),
/** Remembers URL filters without reading anything, for a visit the flag does not render yet. */
storeFilters: (filters: AnalyticsListFilters) => ({ filters }),
clearFilters: true,
clearNarrowingFilters: true,
setSearchInput: (search: string) => ({ search }),
setFeedSearch: (search: string) => ({ search }),
setShownQuery: (query: AnalyticsFeedQuery) => ({ query }),
loadList: true,
loadMore: true,
}),
loaders(({ values }) => ({
folderContents: [
null as FolderContents | null,
{
loadFolderContents: async (_: void, breakpoint) => {
const folder = values.filters.folder
if (folder === null) {
return null
}
const response = await api.fileSystem.list({
parent: folder,
depth: splitPath(folder).length + 1,
search: values.filters.search.trim() || undefined,
limit: FOLDER_PAGE_SIZE,
})
breakpoint()
return {
folder,
entries: response.results,
users: response.users,
hasMore: !!response.next,
}
},
loadMoreFolderContents: async (_: void, breakpoint) => {
const current = values.folderContents
if (!current || !current.hasMore || current.folder !== values.filters.folder) {
return current
}
const response = await api.fileSystem.list({
parent: current.folder,
depth: splitPath(current.folder).length + 1,
search: values.filters.search.trim() || undefined,
limit: FOLDER_PAGE_SIZE,
offset: current.entries.length,
})
breakpoint()
return {
...current,
entries: [...current.entries, ...response.results],
users: [...current.users, ...response.users],
hasMore: !!response.next,
}
},
},
],
})),
reducers({
scope: ['all' as AnalyticsListScope, { setScope: (_, { scope }) => scope }],
filters: [
DEFAULT_ANALYTICS_LIST_FILTERS,
{
setFilters: (state, { filters }) => ({ ...state, ...filters }),
setFiltersFromUrl: (_, { filters }) => filters,
storeFilters: (_, { filters }) => filters,
// The folder is where the person is, not a narrowing, so clearing keeps it.
clearFilters: (state) => ({ ...DEFAULT_ANALYTICS_LIST_FILTERS, folder: state.folder }),
},
],
// What the person has typed. The filters take it after a pause, so each keystroke is not a request.
searchInput: [
'',
{
setSearchInput: (_, { search }) => search,
setFiltersFromUrl: (_, { filters }) => filters.search,
storeFilters: (_, { filters }) => filters.search,
clearFilters: () => '',
},
],
feedSearch: ['', { setFeedSearch: (_, { search }) => search }],
shownQuery: [null as AnalyticsFeedQuery | null, { setShownQuery: (_, { query }) => query }],
folderFailed: [
false,
{
loadFolderContents: () => false,
loadFolderContentsFailure: () => true,
},
],
}),
selectors({
mode: [
(s) => [s.filters],
(filters: AnalyticsListFilters): AnalyticsListMode => (filters.folder !== null ? 'folder' : 'feed'),
],
filtersActive: [
(s) => [s.filters],
(filters: AnalyticsListFilters): boolean => analyticsListFiltersActive(filters),
],
// What the funnel's dot means, so not the search text. My work has no Created by row, so a creator kept from
// View all narrows nothing there.
narrowingFiltersActive: [
(s) => [s.filters, s.scope],
(filters: AnalyticsListFilters, scope: AnalyticsListScope): boolean =>
filters.types.length > 0 ||
filters.tags.length > 0 ||
(scope === 'all' && filters.createdBy.length > 0),
],
// My work narrows to the person; View all narrows to whoever they picked.
// The user record is replaced on every reload; its uuid is not, so the feed query only changes when the person does.
currentUserUuid: [(s) => [s.user], (user: UserType | null): string | null => user?.uuid ?? null],
creators: [
(s) => [s.filters, s.currentUserUuid, s.scope],
(filters: AnalyticsListFilters, currentUserUuid: string | null, scope: AnalyticsListScope): string[] =>
scope === 'mine' ? (currentUserUuid ? [currentUserUuid] : []) : filters.createdBy,
],
// Saved on the person, so the choices follow them across browsers and apply to every Analytics list.
displayConfiguration: [
(s) => [s.uiConfiguration],
(uiConfiguration: UserUIConfiguration | null): AnalyticsListDisplayConfiguration =>
uiConfiguration?.analytics_list ?? {},
],
insightsHidden: [
(s) => [s.displayConfiguration],
(display: AnalyticsListDisplayConfiguration): boolean => !!display.hide_insights,
],
defaultSort: [
(s) => [s.displayConfiguration],
(
display: AnalyticsListDisplayConfiguration
): NonNullable<AnalyticsListDisplayConfiguration['default_sort']> =>
display.default_sort ?? DEFAULT_ANALYTICS_SORT,
],
feedQuery: [
(s) => [s.filters, s.feedSearch, s.creators, s.currentUserUuid, s.defaultSort, s.insightsHidden],
(
filters: AnalyticsListFilters,
feedSearch: string,
creators: string[],
currentUserUuid: string | null,
defaultSort: NonNullable<AnalyticsListDisplayConfiguration['default_sort']>,
insightsHidden: boolean
): AnalyticsFeedQuery => ({
types: filters.types,
// A header click sorts this visit through the URL; the next visit opens on the default again.
orderBy: filters.orderBy ?? defaultSort,
search: feedSearch.trim(),
createdBy: creators,
createdByMe: !!currentUserUuid && creators.length === 1 && creators[0] === currentUserUuid,
tags: filters.tags,
hideInsights: insightsHidden,
}),
],
currentFeed: [
(s) => [s.sources, s.currentTeamId, s.feedQuery],
(
sources: Record<string, AnalyticsSourceState>,
currentTeamId: number | null,
feedQuery: AnalyticsFeedQuery
): AnalyticsFeed => selectAnalyticsFeed(sources, currentTeamId, feedQuery),
],
// While a new query loads, the last loaded list stays on screen, dimmed, so the page does not blink.
feed: [
(s) => [s.currentFeed, s.sources, s.currentTeamId, s.shownQuery],
(
currentFeed: AnalyticsFeed,
sources: Record<string, AnalyticsSourceState>,
currentTeamId: number | null,
shownQuery: AnalyticsFeedQuery | null
): AnalyticsFeed => {
if (currentFeed.initialized || !shownQuery) {
return currentFeed
}
const shownFeed = selectAnalyticsFeed(sources, currentTeamId, shownQuery)
return shownFeed.initialized ? { ...shownFeed, loading: true, hasMore: false } : currentFeed
},
],
feedStale: [
(s) => [s.currentFeed, s.feed],
(currentFeed: AnalyticsFeed, feed: AnalyticsFeed): boolean => !currentFeed.initialized && feed.initialized,
],
items: [
(s) => [s.mode, s.feed, s.folderContents, s.filters, s.insightsHidden],
(
mode: AnalyticsListMode,
feed: AnalyticsFeed,
folderContents: FolderContents | null,
filters: AnalyticsListFilters,
insightsHidden: boolean
): AnalyticsItem[] => {
if (mode === 'feed') {
return feed.items
}
const entries = folderContents?.folder === filters.folder ? folderContents.entries : []
const items = entries.flatMap((entry) => {
const item = ANALYTICS_FILE_SYSTEM_TYPES.has(fileSystemBaseType(entry.type))
? fileSystemEntryToAnalytics(entry, folderContents?.users ?? [])
: null
return item ? [item] : []
})
return filterAnalytics(items, filters, insightsHidden)
},
],
subfolders: [
(s) => [s.mode, s.folderContents, s.filters],
(
mode: AnalyticsListMode,
folderContents: FolderContents | null,
filters: AnalyticsListFilters
): FolderRow[] => {
if (mode !== 'folder' || !folderContents || folderContents.folder !== filters.folder) {
return []
}
// Folders carry no tags, so a tag filter leaves them out.
if (filters.tags.length) {
return []
}
const needle = filters.search.trim().toLowerCase()
return folderContents.entries
.filter((entry) => entry.type === 'folder')
.map((entry) => {
const creator = folderContents.users.find((user) => user.id === entry.meta?.created_by)
return {
path: entry.path,
name: fileSystemEntryName(entry),
entry,
createdAt: entry.created_at ?? null,
createdBy: creator
? {
uuid: creator.uuid,
first_name: creator.first_name,
last_name: creator.last_name,
email: creator.email,
}
: null,
}
})
.filter((folder) => !needle || folder.name.toLowerCase().includes(needle))
.sort((first, second) => first.name.localeCompare(second.name))
},
],
folderBreadcrumbs: [
(s) => [s.filters],
(filters: AnalyticsListFilters): FolderRow[] => {
if (filters.folder === null) {
return []
}
const segments = splitPath(filters.folder)
return segments.map((segment, index) => ({
name: segment,
path: joinPath(segments.slice(0, index + 1)),
}))
},
],
loading: [
(s) => [s.mode, s.feed, s.folderContentsLoading],
(mode: AnalyticsListMode, feed: AnalyticsFeed, folderContentsLoading: boolean): boolean =>
mode === 'feed' ? feed.loading : folderContentsLoading,
],
// Rows fetched so far, before the client-side filters, so the scroll sentinel re-checks after every page
// even when a page added nothing visible.
loadedCount: [
(s) => [s.mode, s.sources, s.feedQuery, s.currentTeamId, s.folderContents],
(
mode: AnalyticsListMode,
sources: Record<string, AnalyticsSourceState>,
feedQuery: AnalyticsFeedQuery,
currentTeamId: number | null,
folderContents: FolderContents | null
): number =>
mode === 'folder'
? (folderContents?.entries.length ?? 0)
: analyticsFeedTypes(feedQuery).reduce(
(sum, type) =>
sum + (sources[analyticsSourceKey(String(currentTeamId), feedQuery, type)]?.offset ?? 0),
0
),
],
hasMore: [
(s) => [s.mode, s.feed, s.folderContents, s.filters],
(
mode: AnalyticsListMode,
feed: AnalyticsFeed,
folderContents: FolderContents | null,
filters: AnalyticsListFilters
): boolean =>
mode === 'feed'
? feed.hasMore
: !!folderContents && folderContents.folder === filters.folder && folderContents.hasMore,
],
failedTypes: [
(s) => [s.mode, s.feed],
(mode: AnalyticsListMode, feed: AnalyticsFeed): AnalyticsFeed['failedTypes'] =>
mode === 'feed' ? feed.failedTypes : [],
],
listState: [
(s) => [s.mode, s.feed, s.folderContents, s.folderFailed, s.items, s.subfolders, s.filtersActive],
(
mode: AnalyticsListMode,
feed: AnalyticsFeed,
folderContents: FolderContents | null,
folderFailed: boolean,
items: AnalyticsItem[],
subfolders: FolderRow[],
filtersActive: boolean
): AnalyticsListState => {
const resolved = mode === 'feed' ? feed.initialized : folderContents !== null
const failed = mode === 'feed' ? feed.loadFailed : folderFailed
if (failed && !items.length) {
return 'error'
}
if (!resolved) {
return 'loading'
}
if (items.length || subfolders.length) {
return 'ready'
}
// Pages can still hold rows a client-side filter left out, so an empty list is not final yet.
if (mode === 'feed' && feed.hasMore) {
return 'loading'
}
return filtersActive ? 'no-matches' : 'empty'
},
],
}),
listeners(({ actions, values, cache }) => {
// Once per visit, however many pages the visit reads.
const reportListLoaded = (viewCount: number, hasMore: boolean): void => {
if (cache.visitStartedAt === undefined) {
return
}
// pinned: analytics event name and properties. Renaming them breaks dashboards.
posthog.capture('views list loaded', {
duration_ms: Math.round(performance.now() - cache.visitStartedAt),
cached: cache.visitCached,
view_count: viewCount,
has_more: hasMore,
mode: values.mode,
})
cache.visitStartedAt = undefined
}
const syncShownQuery = (): void => {
if (values.currentFeed.initialized) {
if (values.shownQuery !== values.feedQuery) {
actions.setShownQuery(values.feedQuery)
}
reportListLoaded(values.currentFeed.items.length, values.currentFeed.hasMore)
}
}
// The setting is one JSON value on the user, so other UI settings in it must survive the write.
const updateDisplay = (change: AnalyticsListDisplayConfiguration): void => {
const current = values.uiConfiguration
actions.updateUiConfiguration(
{
...current,
version: current?.version ?? 1,
analytics_list: { ...current?.analytics_list, ...change },
},
undefined,
() => {
// A failed save puts the old setting back, and the list may never have loaded for it.
if (values.mode === 'feed') {
loadCurrentMode()
}
}
)
}
const loadCurrentMode = (): void => {
if (values.mode === 'feed') {
actions.ensureFeed(values.feedQuery, ANALYTICS_PREFETCH_COUNT)
syncShownQuery()
} else {
actions.loadFolderContents()
}
}
return {
[featureFlagLogic.actionTypes.setFeatureFlags]: () => {
// Flags can arrive after urlToAction ran, so a visit that skipped the load must load now.
if (
values.featureFlags[FEATURE_FLAGS.TODAY_RAIL_NAV] &&
cache.visitStartedAt === undefined &&
!values.loading &&
[urls.analyticsList(), urls.analyticsMine()].includes(
removeProjectIdIfPresent(router.values.location.pathname)
)
) {
actions.loadList()
}
},
loadList: () => {
cache.visitStartedAt = performance.now()
cache.visitCached = values.mode === 'feed' ? values.currentFeed.initialized : !!values.folderContents
if (values.mode === 'feed') {
actions.refreshFeed(values.feedQuery)
syncShownQuery()
} else {
actions.loadFolderContents()
}
},
loadMore: () => {
if (!values.hasMore) {
return
}
if (values.mode === 'folder') {
actions.loadMoreFolderContents()
} else {
actions.ensureFeed(values.feedQuery, values.feed.items.length + ANALYTICS_PREFETCH_COUNT)
}
},
setSearchInput: async ({ search }, breakpoint) => {
if (search.trim() !== values.filters.search.trim()) {
await breakpoint(search.trim() ? 200 : 0)
}
actions.setFilters({ search })
},
setInsightsHidden: ({ hidden }) => {
// pinned: analytics event name and properties. Renaming them breaks dashboards.
posthog.capture('analytics insights toggled', {
hidden,
scope: values.scope,
folder: values.filters.folder !== null,
})
updateDisplay({ hide_insights: hidden })
if (hidden && values.filters.types.includes('insight')) {
// The insight option goes away, so the list cannot stay on it.
actions.setFilters({ types: values.filters.types.filter((type) => type !== 'insight') })
} else if (values.mode === 'feed') {
// A folder's rows are already loaded and narrowed on the client.
loadCurrentMode()
}
},
setDefaultSort: ({ orderBy }) => {
// pinned: analytics event name and properties. Renaming them breaks dashboards.
posthog.capture('analytics default sort changed', { order_by: orderBy, scope: values.scope })
updateDisplay({ default_sort: orderBy })
// The person just chose the order, so a sort from a header click or a link gives way to it.
if (values.filters.orderBy) {
actions.setFilters({ orderBy: undefined })
} else if (values.mode === 'feed') {
loadCurrentMode()
}
},
setFilters: ({ filters }) => {
if (filters.search !== undefined) {
actions.setFeedSearch(filters.search)
}
const changed = Object.keys(filters).filter((key) => key !== 'search')
if (changed.length) {
// pinned: analytics event name and `type` property. Renaming them breaks dashboards.
posthog.capture('views list filtered', {
type: values.filters.types.length > 1 ? 'multiple' : (values.filters.types[0] ?? 'all'),
changed,
created_by: !values.filters.createdBy.length
? 'anyone'
: values.user?.uuid && values.filters.createdBy.includes(values.user.uuid)
? 'me'
: 'other',
folder: values.filters.folder !== null,
tag_count: values.filters.tags.length,
})
}
loadCurrentMode()
},
setFiltersFromUrl: () => {
actions.setFeedSearch(values.filters.search)
actions.loadList()
},
clearNarrowingFilters: () => {
actions.setFilters({ types: [], createdBy: [], tags: [] })
},
clearFilters: () => {
actions.setFeedSearch('')
loadCurrentMode()
},
sourceRefreshed: () => {
syncShownQuery()
// Unfiled rows stay hidden, so a page can add nothing visible; keep reading until the list fills.
if (values.mode === 'feed' && values.hasMore && values.items.length < ANALYTICS_PREFETCH_COUNT) {
actions.loadMore()
}
},
loadFolderContentsSuccess: ({ folderContents }) => {
if (!folderContents) {
return
}
reportListLoaded(folderContents.entries.length, folderContents.hasMore)
if (cache.openedFolder !== folderContents.folder) {
cache.openedFolder = folderContents.folder
// pinned: analytics event name and properties. Renaming them breaks dashboards.
posthog.capture('analytics collection opened', {
nested: splitPath(folderContents.folder).length > 1,
item_count: folderContents.entries.length,
})
}
},
// A move or a new folder changes what this list holds, so it reads again.
shareToSpaceDone: () => actions.loadList(),
folderCreated: () => actions.loadList(),
// Drags and folder deletes go through the project tree, which reports here once they land.
movesSettled: () => actions.loadList(),
deleteSavedItem: ({ savedItem }) => {
const folder = values.filters.folder
if (savedItem.type === 'folder' && folder && isPathUnder(folder, savedItem.path)) {
const parent = splitPath(savedItem.path).slice(0, -1)
router.actions.push(
parent.length ? urls.analyticsList({ folder: joinPath(parent) }) : urls.analyticsSpaces()
)
return
}
actions.loadList()
},
}
}),
actionToUrl(({ values }) => {
const toUrl = (): string => {
return values.scope === 'mine'
? urls.analyticsMine(analyticsListUrlParams(values.filters))
: urls.analyticsList(analyticsListUrlParams(values.filters))
}
return {
setFilters: toUrl,
clearFilters: toUrl,
}
}),
urlToAction(({ actions, values, cache }) => {
const listPaths = [urls.analyticsList(), urls.analyticsMine()]
// The router only writes a URL that differs from the current one, so our own write is the one location
// change that moves the URL within this scene while the scope and filters stay as they are.
const isOwnUrlWrite = (previous: { pathname: string; search: string }): boolean =>
listPaths.includes(removeProjectIdIfPresent(previous.pathname)) &&
previous.search !== router.values.location.search
const open = (
scope: AnalyticsListScope,
searchParams: Record<string, any>,
previous: { pathname: string; search: string }
): void => {
const scopeChanged = values.scope !== scope
if (scopeChanged) {
actions.setScope(scope)
}
// The filters apply even before the flags arrive, so a cold open lands on the right list once they do.
const filters = analyticsListFiltersFromUrl(searchParams)
const filtersChanged = JSON.stringify(filters) !== JSON.stringify(values.filters)
// The scene renders nothing without the flag, so it must not load anything either.
if (!values.featureFlags[FEATURE_FLAGS.TODAY_RAIL_NAV]) {
if (filtersChanged) {
actions.storeFilters(filters)
}
return
}
if (filtersChanged) {
// A cold open with filters is a visit too, so it reports `views list loaded` like a plain one.
cache.visitStartedAt = performance.now()
cache.visitCached = false
actions.setFiltersFromUrl(filters)
} else if (scopeChanged || !isOwnUrlWrite(previous)) {
// A visit shows the last loaded rows at once and reads again, so a new item shows up on return.
actions.loadList()
}
}
return {
[urls.analyticsList()]: (_, searchParams, __, ___, previous) => open('all', searchParams, previous),
[urls.analyticsMine()]: (_, searchParams, __, ___, previous) => open('mine', searchParams, previous),
}
}),
])