: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 Papa from 'papaparse'
import { lemonToast } from '@posthog/lemon-ui'
import { copyToClipboard } from 'lib/utils/copyToClipboard'
import { DataTableNode, NodeKind } from '~/queries/schema/schema-general'
import {
copyTableToCsv,
copyTableToExcel,
copyTableToJson,
copyTableToMarkdown,
flattenObject,
getCsvTableData,
getJsonTableData,
projectExportRows,
} from './clipboardUtils'
import { DataTableRow } from './dataTableLogic'
jest.mock('lib/utils/copyToClipboard')
jest.mock('@posthog/lemon-ui', () => ({
lemonToast: {
error: jest.fn(),
},
}))
jest.mock('papaparse', () => ({
unparse: jest.fn((data: unknown[][], options: { delimiter?: string } = {}) => {
const delimiter = options.delimiter || ','
return data.map((row: unknown[]) => row.join(delimiter)).join('\n')
}),
}))
const mockCopyToClipboard = copyToClipboard as jest.MockedFunction<typeof copyToClipboard>
const mockLemonToastError = lemonToast.error as jest.MockedFunction<typeof lemonToast.error>
const mockPapaUnparse = Papa.unparse as jest.MockedFunction<typeof Papa.unparse>
type DataTableSourceKind = DataTableNode['source']['kind']
const createMockQuery = (
sourceKind: DataTableSourceKind,
additionalProps: Record<string, unknown> = {}
): DataTableNode => ({
kind: NodeKind.DataTableNode,
source: { kind: sourceKind, ...additionalProps } as DataTableNode['source'],
})
describe('clipboardUtils', () => {
beforeEach(() => {
jest.clearAllMocks()
})
describe('flattenObject', () => {
it('returns primitive values with default key when prefix is provided', () => {
expect(flattenObject('test', 'someKey')).toEqual({ someKey: 'test' })
expect(flattenObject(123, 'someKey')).toEqual({ someKey: 123 })
expect(flattenObject(true, 'someKey')).toEqual({ someKey: true })
expect(flattenObject(null, 'someKey')).toEqual({ someKey: null })
expect(flattenObject(undefined, 'someKey')).toEqual({ someKey: undefined })
})
it('returns raw primitive values when prefix is empty string', () => {
expect(flattenObject('test', '')).toBe('test')
expect(flattenObject(123, '')).toBe(123)
expect(flattenObject(true, '')).toBe(true)
expect(flattenObject(null, '')).toBe(null)
expect(flattenObject(undefined, '')).toBe(undefined)
})
it('returns arrays with default key when prefix is provided', () => {
const arr = [1, 2, 3]
expect(flattenObject(arr, 'someKey')).toEqual({ someKey: arr })
})
it('returns raw arrays when prefix is empty string', () => {
const arr = [1, 2, 3]
expect(flattenObject(arr, '')).toBe(arr)
})
it('uses fallback "value" key when prefix is null/undefined', () => {
expect(flattenObject('test', null as any)).toEqual({ value: 'test' })
expect(flattenObject('test', undefined)).toEqual({ value: 'test' })
})
it('flattens nested objects', () => {
const nested = {
level1: {
level2: { value: 'deep' },
simple: 'test',
},
direct: 'value',
}
expect(flattenObject(nested)).toEqual({
'level1.level2.value': 'deep',
'level1.simple': 'test',
direct: 'value',
})
})
it('uses custom prefix and separator', () => {
const obj = { a: { b: 'value' } }
expect(flattenObject(obj, 'prefix', '_')).toEqual({
prefix_a_b: 'value',
})
})
it('handles mixed data types', () => {
const complex = {
string: 'test',
number: 42,
boolean: true,
nullValue: null,
arrayValue: [1, 2, 3],
nested: { deep: 'value' },
}
expect(flattenObject(complex, 'root')).toEqual({
'root.string': 'test',
'root.number': 42,
'root.boolean': true,
'root.nullValue': null,
'root.arrayValue': [1, 2, 3],
'root.nested.deep': 'value',
})
})
})
describe('getCsvTableData', () => {
it('handles EventsQuery with person column', () => {
const query = createMockQuery(NodeKind.EventsQuery, { select: ['event', 'person'] })
const columns = ['event', 'person']
const rows: DataTableRow[] = [
{
result: [
'pageview',
{
distinct_id: 'user_123',
properties: { email: '[email protected]' },
},
],
},
]
const result = getCsvTableData(rows, columns, query)
expect(result[0]).toContain('event')
expect(result[0]).toContain('person')
expect(result[1][0]).toBe('pageview')
expect(result[1][1]).toBe('[email protected]') // asDisplay returns email (person display property)
})
it('handles ActorsQuery with a person display name column', () => {
const columns = ['person_display_name -- Person', 'properties.email -- Email']
const query = createMockQuery(NodeKind.ActorsQuery, { select: columns })
const rows: DataTableRow[] = [
{ result: [{ display_name: 'Ana', id: 'uuid-1', distinct_id: 'ana' }, '[email protected]'] },
]
expect(getCsvTableData(rows, columns, query)).toEqual([
['Person', 'Email'],
['Ana', '[email protected]'],
])
})
it('handles PersonsNode with nested properties', () => {
const query = createMockQuery(NodeKind.PersonsNode)
const columns = ['email', 'properties']
const rows: DataTableRow[] = [
{
result: {
email: '[email protected]',
properties: { age: 25, location: { city: 'NYC' } },
name: 'Test User',
},
},
]
const result = getCsvTableData(rows, columns, query)
expect(result[0]).toContain('email')
expect(result[0]).toContain('properties.age')
expect(result[0]).toContain('properties.location.city')
expect(result[1]).toContain('[email protected]')
expect(result[1]).toContain(25)
expect(result[1]).toContain('NYC')
})
it('handles HogQLQuery source', () => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
const columns = ['event', 'properties']
const rows: DataTableRow[] = [{ result: ['click', { button_id: 'submit', metadata: { source: 'form' } }] }]
const result = getCsvTableData(rows, columns, query)
expect(result[0]).toContain('event')
expect(result[0]).toContain('properties.button_id')
expect(result[0]).toContain('properties.metadata.source')
expect(result[1]).toContain('click')
expect(result[1]).toContain('submit')
expect(result[1]).toContain('form')
})
it.each([
{
name: 'keeps the query column order and puts flattened sub-columns after their parent',
columns: ['b', 'obj', 'a'],
rows: [{ result: ['b1', { z: 1, y: 2 }, 'a1'] }, { result: ['b2', { x: 3 }, 'a2'] }],
expected: [
['b', 'obj.z', 'obj.y', 'obj.x', 'a'],
['b1', 1, 2, '', 'a1'],
['b2', '', '', 3, 'a2'],
],
},
{
name: 'keeps every value when two columns have the same name',
columns: ['id', 'id'],
rows: [{ result: [1, 2] }],
expected: [
['id', 'id'],
[1, 2],
],
},
])('$name', ({ columns, rows, expected }) => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT 1' })
expect(getCsvTableData(rows, columns, query)).toEqual(expected)
})
it('returns empty array for unsupported query types', () => {
// Create a query with an unsupported source by bypassing type safety
const query: DataTableNode = {
kind: NodeKind.DataTableNode,
source: { kind: 'UnsupportedQuery' as any },
}
const result = getCsvTableData([], ['event'], query)
expect(result).toEqual([])
})
})
describe('getJsonTableData', () => {
it('handles EventsQuery with column extraction', () => {
const query = createMockQuery(NodeKind.EventsQuery, { select: ['event', 'timestamp -- Timestamp'] })
const columns = ['event', 'timestamp -- Timestamp']
const rows: DataTableRow[] = [{ result: ['pageview', '2023-01-01T00:00:00Z'] }]
const result = getJsonTableData(rows, columns, query)
expect(result).toHaveLength(1)
expect(result[0].event).toBe('pageview')
expect(result[0].Timestamp).toBe('2023-01-01T00:00:00Z')
})
it('handles PersonsNode source', () => {
const query = createMockQuery(NodeKind.PersonsNode)
const columns = ['email', 'created_at']
const rows: DataTableRow[] = [
{ result: { email: '[email protected]', created_at: '2023-01-01', name: 'Test User' } },
]
const result = getJsonTableData(rows, columns, query)
expect(result).toHaveLength(1)
expect(result[0].email).toBe('[email protected]')
expect(result[0].created_at).toBe('2023-01-01')
})
it('handles HogQLQuery source', () => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
const columns = ['event', 'count']
const rows: DataTableRow[] = [{ result: ['pageview', 42] }]
const result = getJsonTableData(rows, columns, query)
expect(result).toHaveLength(1)
expect(result[0].event).toBe('pageview')
expect(result[0].count).toBe(42)
})
it('filters disallowed columns', () => {
const query = createMockQuery(NodeKind.EventsQuery, { select: ['event', 'person.$delete'] })
const columns = ['event', 'person.$delete']
const rows: DataTableRow[] = [{ result: ['pageview', 'delete_value'] }]
const result = getJsonTableData(rows, columns, query)
expect(result).toHaveLength(1)
expect(result[0].event).toBe('pageview')
expect(result[0]['person.$delete']).toBeUndefined()
})
it('returns empty array for unsupported query types', () => {
// Create a query with an unsupported source by bypassing type safety
const query: DataTableNode = {
kind: NodeKind.DataTableNode,
source: { kind: 'UnsupportedQuery' as any },
}
const result = getJsonTableData([], ['event'], query)
expect(result).toEqual([])
})
})
describe('copyTableToCsv', () => {
it('copies CSV data to clipboard', () => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
const columns = ['event']
const rows: DataTableRow[] = [{ result: ['pageview'] }]
copyTableToCsv(rows, columns, query)
copyTableToCsv(rows, columns, query, false)
expect(mockCopyToClipboard).toHaveBeenNthCalledWith(1, 'event\npageview', 'table')
expect(mockCopyToClipboard).toHaveBeenNthCalledWith(2, 'pageview', 'table')
})
it('shows error on copy failure', () => {
mockCopyToClipboard.mockImplementation(() => {
throw new Error('Copy failed')
})
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
copyTableToCsv([{ result: ['pageview'] }], ['event'], query)
expect(mockLemonToastError).toHaveBeenCalledWith('Copy failed!')
})
})
describe('copyTableToJson', () => {
it('copies JSON data to clipboard', () => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
const columns = ['event']
const rows: DataTableRow[] = [{ result: ['pageview'] }]
copyTableToJson(rows, columns, query)
const expectedJson = JSON.stringify([{ event: 'pageview' }], null, 4)
expect(mockCopyToClipboard).toHaveBeenCalledWith(expectedJson, 'table')
})
it('shows error on copy failure', () => {
mockCopyToClipboard.mockImplementation(() => {
throw new Error('Copy failed')
})
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
copyTableToJson([{ result: ['pageview'] }], ['event'], query)
expect(mockLemonToastError).toHaveBeenCalledWith('Copy failed!')
})
})
describe('copyTableToExcel', () => {
it('copies TSV data with tab delimiter', () => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
const columns = ['event', 'timestamp', 'user_id']
const rows: DataTableRow[] = [
{ result: ['pageview', '2023-01-01T00:00:00Z', 'user123'] },
{ result: ['click', '2023-01-01T00:01:00Z', 'user456'] },
]
copyTableToExcel(rows, columns, query)
const expectedData = [
['event', 'timestamp', 'user_id'],
['pageview', '2023-01-01T00:00:00Z', 'user123'],
['click', '2023-01-01T00:01:00Z', 'user456'],
]
expect(mockPapaUnparse).toHaveBeenCalledWith(expectedData, { delimiter: '\t' })
const expectedOutput =
'event\ttimestamp\tuser_id\npageview\t2023-01-01T00:00:00Z\tuser123\nclick\t2023-01-01T00:01:00Z\tuser456'
expect(mockCopyToClipboard).toHaveBeenCalledWith(expectedOutput, 'table')
})
it('shows error on copy failure', () => {
mockCopyToClipboard.mockImplementation(() => {
throw new Error('Copy failed')
})
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
copyTableToExcel([{ result: ['pageview'] }], ['event'], query)
expect(mockLemonToastError).toHaveBeenCalledWith('Copy failed!')
})
it('handles Papa.unparse failure', () => {
mockPapaUnparse.mockImplementation(() => {
throw new Error('Papa parse failed')
})
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
copyTableToExcel([{ result: ['pageview'] }], ['event'], query)
expect(mockLemonToastError).toHaveBeenCalledWith('Copy failed!')
})
})
describe('copyTableToMarkdown', () => {
it('copies a padded markdown table to clipboard', () => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
const columns = ['name', 'age', 'city']
const rows: DataTableRow[] = [
{ result: ['Alice', 30, 'New York'] },
{ result: ['Bob', 25, 'San Francisco'] },
]
copyTableToMarkdown(rows, columns, query)
const expected = [
'| name | age | city |',
'| ----- | --- | ------------- |',
'| Alice | 30 | New York |',
'| Bob | 25 | San Francisco |',
].join('\n')
expect(mockCopyToClipboard).toHaveBeenCalledWith(expected, 'table')
})
it.each([
{
name: 'pads short header names to match data width',
columns: ['n', 'v'],
rows: [{ result: ['very_long_value', 'x'] }],
// 'n' column: max(3, 1, 15) = 15; 'v' column: max(3, 1, 1) = 3
expected: ['| n | v |', '| --------------- | --- |', '| very_long_value | x |'].join(
'\n'
),
},
{
name: 'escapes pipe characters in header and cell values',
columns: ['\\nexpr|rpxe\n\r\n\r'],
rows: [{ result: ['a|b|'] }],
expected: [
String.raw`| \nexpr\|rpxe\n\r\n\r |`,
String.raw`| -------------------- |`,
String.raw`| a\|b\| |`,
].join('\n'),
},
{
name: 'handles null and undefined cell values',
columns: ['col'],
rows: [{ result: [null] }, { result: [undefined] }],
expected: ['| col |', '| --- |', '| |', '| |'].join('\n'),
},
])('$name', ({ columns, rows, expected }) => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
copyTableToMarkdown(rows as DataTableRow[], columns, query)
expect(mockCopyToClipboard).toHaveBeenCalledWith(expected, 'table')
})
it('shows error toast when no data is returned', () => {
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
copyTableToMarkdown([], ['event'], query)
expect(mockLemonToastError).toHaveBeenCalledWith('No data to copy!')
expect(mockCopyToClipboard).not.toHaveBeenCalled()
})
it('shows error on copy failure', () => {
mockCopyToClipboard.mockImplementation(() => {
throw new Error('Copy failed')
})
const query = createMockQuery(NodeKind.HogQLQuery, { query: 'SELECT * FROM events' })
copyTableToMarkdown([{ result: ['pageview'] }], ['event'], query)
expect(mockLemonToastError).toHaveBeenCalledWith('Copy failed!')
})
})
describe('edge cases and failures', () => {
it('handles data with circular references in JSON', () => {
// Create circular reference
const circularObj: any = { name: 'test' }
circularObj.self = circularObj
const query = createMockQuery(NodeKind.PersonsNode)
const rows: DataTableRow[] = [{ result: circularObj }]
// Mock JSON.stringify to throw on circular reference
const originalStringify = JSON.stringify
jest.spyOn(JSON, 'stringify').mockImplementation(() => {
throw new TypeError('Converting circular structure to JSON')
})
copyTableToJson(rows, ['name'], query)
expect(mockLemonToastError).toHaveBeenCalledWith('Copy failed!')
// Restore original
JSON.stringify = originalStringify
})
})
})
describe('projectExportRows', () => {
it('preserves answer and outcome columns while excluding internal row metadata', () => {
const rows = [{ result: [{ properties: { internal: true } }, 'Useful examples', 'dismissed', 'event-id'] }]
expect(projectExportRows(rows, ['response', 'answer', 'status', 'actions'], ['answer', 'status'])).toEqual([
{ result: ['Useful examples', 'dismissed'] },
])
})
})