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.

19.2 KB
Raw Blame
import {
    AnyEntityNode,
    EventsHeatMapDataResult,
    InsightVizNode,
    NodeKind,
    TrendsQueryResponse,
} from '~/queries/schema/schema-general'

import {
    CalendarHeatmapAdapter,
    TrendsAdapter,
    WorldMapAdapter,
    csvFromTableData,
    getInsightExportAdapter,
} from './exportAdapters'

describe('insight export adapters', () => {
    const trendsQuery: InsightVizNode = {
        kind: NodeKind.InsightVizNode,
        source: {
            kind: NodeKind.TrendsQuery,
            series: [],
        },
    }

    describe('csvFromTableData', () => {
        it.each(['=', '+', '-', '@'])(
            'neutralizes a leading "%s" so spreadsheets do not evaluate the cell as a formula',
            (prefix) => {
                const csv = csvFromTableData([['header'], [`${prefix}cmd(1)`]])
                expect(csv).toContain(`'${prefix}cmd(1)`)
                expect(csv).not.toContain(`\n${prefix}cmd(1)`)
            }
        )
    })

    describe('getInsightExportAdapter', () => {
        it('normalizes cached insight models that carry the series under legacy `result`', () => {
            const cachedInsight = {
                result: [{ label: 'Pageview', data: [10, 15], labels: ['2024-01-01', '2024-01-02'] }],
            }

            const adapter = getInsightExportAdapter(cachedInsight, trendsQuery)

            expect(adapter?.toTableData()).toEqual([
                ['Date', 'Pageview'],
                ['2024-01-01', '10'],
                ['2024-01-02', '15'],
            ])
        })

        it('returns null for insight kinds without an adapter', () => {
            const funnelsQuery: InsightVizNode = {
                kind: NodeKind.InsightVizNode,
                source: {
                    kind: NodeKind.FunnelsQuery,
                    series: [],
                },
            }

            expect(getInsightExportAdapter({ results: [{ label: 'Step 1' }] }, funnelsQuery)).toBeNull()
        })
    })

    describe('CalendarHeatmapAdapter', () => {
        it('converts calendar heatmap data to table format', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        calendar_heatmap_data: {
                            data: [
                                { row: 0, column: 0, value: 10 },
                                { row: 0, column: 1, value: 15 },
                                { row: 1, column: 0, value: 20 },
                                { row: 1, column: 1, value: 25 },
                            ],
                            rowAggregations: [
                                { row: 0, value: 25 },
                                { row: 1, value: 45 },
                            ],
                            columnAggregations: [
                                { column: 0, value: 30 },
                                { column: 1, value: 40 },
                            ],
                            allAggregations: 70,
                        },
                    },
                ],
            }

            const adapter = new CalendarHeatmapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toHaveLength(9) // 1 header + 7 data rows + 1 aggregation row
            expect(result[0]).toEqual(['', ...Array.from({ length: 24 }, (_, i) => String(i)), 'All'])
            expect(result[1][0]).toBe('Sun')
            expect(result[1][1]).toBe('10')
            expect(result[1][2]).toBe('15')
            expect(result[1][25]).toBe('25')
            expect(result[2][0]).toBe('Mon')
            expect(result[2][1]).toBe('20')
            expect(result[2][2]).toBe('25')
            expect(result[2][25]).toBe('45')
            expect(result[8][1]).toBe('30')
            expect(result[8][2]).toBe('40')
            expect(result[8][25]).toBe('70')
        })

        it('handles sparse data with missing cells', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        calendar_heatmap_data: {
                            data: [{ row: 0, column: 1, value: 15 }],
                            rowAggregations: [{ row: 0, value: 15 }],
                            columnAggregations: [{ column: 1, value: 15 }],
                            allAggregations: 15,
                        },
                    },
                ],
            }

            const adapter = new CalendarHeatmapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toHaveLength(9) // 1 header + 7 data rows + 1 aggregation row
            expect(result[0]).toHaveLength(26) // empty + 24 hours + All
            expect(result[1][1]).toBe('0') // Sun, hour 0
            expect(result[1][2]).toBe('15') // Sun, hour 1
            expect(result[1][25]).toBe('15') // Sun, row total
        })

        it('handles empty heatmap data', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        calendar_heatmap_data: {
                            data: [],
                            rowAggregations: [],
                            columnAggregations: [],
                            allAggregations: 0,
                        },
                    },
                ],
            }

            const adapter = new CalendarHeatmapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toHaveLength(9) // 1 header + 7 data rows + 1 aggregation row
            expect(result[0]).toHaveLength(26) // empty + 24 hours + All
            expect(result[8][25]).toBe('0') // All row, All column
        })

        it('returns empty array when heatmap data is missing', () => {
            const response: TrendsQueryResponse = {
                results: [{}],
            }

            const adapter = new CalendarHeatmapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([])
        })

        it('handles full day x hour matrix (7x24)', () => {
            const data: EventsHeatMapDataResult[] = []
            for (let row = 0; row < 7; row++) {
                for (let col = 0; col < 24; col++) {
                    data.push({ row, column: col, value: row * 24 + col })
                }
            }

            const response: TrendsQueryResponse = {
                results: [
                    {
                        calendar_heatmap_data: {
                            data,
                            rowAggregations: Array.from({ length: 7 }, (_, i) => ({
                                row: i,
                                value: (i * 24 * (i * 24 + 23)) / 2,
                            })),
                            columnAggregations: Array.from({ length: 24 }, (_, i) => ({ column: i, value: i * 7 })),
                            allAggregations: 19656,
                        },
                    },
                ],
            }

            const adapter = new CalendarHeatmapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result.length).toBe(9) // 1 header + 7 data rows + 1 aggregation row
            expect(result[0].length).toBe(26) // empty + 24 hours + All
            expect(result[0][0]).toBe('')
            expect(result[0][1]).toBe('0')
            expect(result[0][24]).toBe('23')
            expect(result[0][25]).toBe('All')
        })

        it('correctly converts ClickHouse day indices (1=Mon, 7=Sun) to standard format (0=Sun, 6=Sat)', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        calendar_heatmap_data: {
                            data: [
                                { row: 7, column: 0, value: 100 }, // Sunday
                                { row: 7, column: 1, value: 110 },
                                { row: 1, column: 0, value: 200 }, // Monday
                                { row: 1, column: 1, value: 210 },
                                { row: 6, column: 0, value: 600 }, // Saturday
                                { row: 6, column: 1, value: 610 },
                            ],
                            rowAggregations: [
                                { row: 7, value: 210 },
                                { row: 1, value: 410 },
                                { row: 6, value: 1210 },
                            ],
                            columnAggregations: [
                                { column: 0, value: 900 },
                                { column: 1, value: 930 },
                            ],
                            allAggregations: 1830,
                        },
                    },
                ],
            }

            const adapter = new CalendarHeatmapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result[1][0]).toBe('Sun')
            expect(result[1][1]).toBe('100')
            expect(result[1][2]).toBe('110')
            expect(result[1][25]).toBe('210')

            expect(result[2][0]).toBe('Mon')
            expect(result[2][1]).toBe('200')
            expect(result[2][2]).toBe('210')
            expect(result[2][25]).toBe('410')

            expect(result[7][0]).toBe('Sat')
            expect(result[7][1]).toBe('600')
            expect(result[7][2]).toBe('610')
            expect(result[7][25]).toBe('1210')

            expect(result[8][1]).toBe('900')
            expect(result[8][2]).toBe('930')
            expect(result[8][25]).toBe('1830')
        })
    })

    describe('TrendsAdapter', () => {
        it('converts trends data to table format', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'Pageview',
                        data: [10, 15, 20],
                        labels: ['2024-01-01', '2024-01-02', '2024-01-03'],
                    },
                    {
                        label: 'Button Click',
                        data: [5, 8, 12],
                        labels: ['2024-01-01', '2024-01-02', '2024-01-03'],
                    },
                ],
            }

            const adapter = new TrendsAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([
                ['Date', 'Pageview', 'Button Click'],
                ['2024-01-01', '10', '5'],
                ['2024-01-02', '15', '8'],
                ['2024-01-03', '20', '12'],
            ])
        })

        it.each<[string, AnyEntityNode, string]>([
            [
                'a custom name',
                { kind: NodeKind.EventsNode, event: 'pageview', custom_name: 'Page Views' },
                'Page Views',
            ],
            ['a name other than the event', { kind: NodeKind.EventsNode, event: 'pageview', name: 'Views' }, 'Views'],
            [
                'the label when the name matches it',
                { kind: NodeKind.EventsNode, event: 'pageview', name: 'pageview' },
                'pageview',
            ],
        ])('names the series by %s', (_, node, expected) => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'pageview',
                        order: 0,
                        data: [10, 15],
                        labels: ['2024-01-01', '2024-01-02'],
                    },
                ],
            }
            const renamedQuery: InsightVizNode = {
                kind: NodeKind.InsightVizNode,
                source: { kind: NodeKind.TrendsQuery, series: [node] },
            }

            const adapter = new TrendsAdapter(response, renamedQuery)
            const result = adapter.toTableData()

            expect(result[0]).toEqual(['Date', expected])
        })

        it('includes compare_label when present', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'Pageview',
                        compare_label: 'current',
                        data: [10, 15],
                        labels: ['2024-01-01', '2024-01-02'],
                    },
                    {
                        label: 'Pageview',
                        compare_label: 'previous',
                        data: [8, 12],
                        labels: ['2024-01-01', '2024-01-02'],
                    },
                ],
            }

            const adapter = new TrendsAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result[0]).toEqual(['Date', 'Pageview (current)', 'Pageview (previous)'])
        })

        it('uses days as fallback for date labels', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'Event',
                        data: [10, 15],
                        days: ['2024-01-01', '2024-01-02'],
                    },
                ],
            }

            const adapter = new TrendsAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result[1]).toEqual(['2024-01-01', '10'])
            expect(result[2]).toEqual(['2024-01-02', '15'])
        })

        it('returns empty array for empty results', () => {
            const response: TrendsQueryResponse = {
                results: [],
            }

            const adapter = new TrendsAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([])
        })

        it('returns empty array when there are no date labels and no aggregated values', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'Event',
                        data: [10, 15],
                    },
                ],
            }

            const adapter = new TrendsAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([])
        })

        it('falls back to one row per series for value-aggregated displays', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'Chrome',
                        aggregated_value: 100,
                        data: [],
                        days: [],
                        labels: [],
                    } as any,
                    {
                        label: 'Safari',
                        aggregated_value: 50.5,
                        data: [],
                        days: [],
                        labels: [],
                    } as any,
                ],
            }

            const adapter = new TrendsAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([
                ['Series', 'Total value'],
                ['Chrome', '100'],
                ['Safari', '50.5'],
            ])
        })

        it('handles null values in data', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'Event',
                        data: [10, null, 20] as any,
                        labels: ['2024-01-01', '2024-01-02', '2024-01-03'],
                    },
                ],
            }

            const adapter = new TrendsAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([
                ['Date', 'Event'],
                ['2024-01-01', '10'],
                ['2024-01-02', ''],
                ['2024-01-03', '20'],
            ])
        })

        it('uses breakdown_value when available instead of label', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'Unique visitors',
                        breakdown_value: 'Organic Search',
                        data: [335, 348],
                        labels: ['2024-01-01', '2024-01-02'],
                    } as any,
                    {
                        label: 'Unique visitors',
                        breakdown_value: 'Direct',
                        data: [0, 0],
                        labels: ['2024-01-01', '2024-01-02'],
                    } as any,
                ],
            }

            const adapter = new TrendsAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result[0]).toEqual(['Date', 'Organic Search', 'Direct'])
            expect(result[1]).toEqual(['2024-01-01', '335', '0'])
            expect(result[2]).toEqual(['2024-01-02', '348', '0'])
        })
    })

    describe('WorldMapAdapter', () => {
        it('converts world map data to table format', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'US',
                        aggregated_value: 45319,
                        data: [],
                        days: [],
                    } as any,
                    {
                        label: 'GB',
                        aggregated_value: 12345,
                        data: [],
                        days: [],
                    } as any,
                ],
            }

            const adapter = new WorldMapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([
                ['Country', 'Visitors'],
                ['US', '45319'],
                ['GB', '12345'],
            ])
        })

        it('handles empty results', () => {
            const response: TrendsQueryResponse = {
                results: [],
            }

            const adapter = new WorldMapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([])
        })

        it('handles missing aggregated_value with fallback to count', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        label: 'US',
                        count: 100,
                        data: [],
                        days: [],
                    } as any,
                ],
            }

            const adapter = new WorldMapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([
                ['Country', 'Visitors'],
                ['US', '100'],
            ])
        })

        it('handles missing label', () => {
            const response: TrendsQueryResponse = {
                results: [
                    {
                        aggregated_value: 50,
                        data: [],
                        days: [],
                    } as any,
                ],
            }

            const adapter = new WorldMapAdapter(response, trendsQuery)
            const result = adapter.toTableData()

            expect(result).toEqual([
                ['Country', 'Visitors'],
                ['', '50'],
            ])
        })
    })
})