: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 { extractExpressionComment, removeExpressionComment } from '~/queries/nodes/DataTable/utils'
import { isActorsQuery, isHogQLQuery, isPersonsNode } from '~/queries/schema/node-guards'
import { DataTableNode } from '~/queries/schema/schema-general'
import { isEventsQuery, isMarketingAnalyticsTableQuery } from '~/queries/utils'
import { asDisplay } from 'products/persons/frontend/person-utils'
import { DataTableRow } from './dataTableLogic'
export function projectExportRows(rows: DataTableRow[], columns: string[], exportColumns: string[]): DataTableRow[] {
const indexes = exportColumns.map((column) => columns.indexOf(column))
return rows.map((row) => {
const result = row.result
return Array.isArray(result) ? { ...row, result: indexes.map((index) => result[index]) } : row
})
}
const columnDisallowList = ['person.$delete', '*']
// Helper function to recursively flatten objects for CSV export
export const flattenObject = (obj: any, prefix?: string, separator = '.'): Record<string, any> => {
const flattened: Record<string, any> = {}
if (obj === null || obj === undefined) {
if (prefix === '') {
return obj
}
return { [prefix || 'value']: obj }
}
if (typeof obj !== 'object' || Array.isArray(obj)) {
if (prefix === '') {
return obj
}
return { [prefix || 'value']: obj }
}
// Example: { value: 1, value2: 2, nested: { a: 3, b: 4 } } with prefix 'col'
// Should produce: { 'col.value': 1, 'col.value2': 2, 'col.nested.a': 3, 'col.nested.b': 4 }
for (const [key, value] of Object.entries(obj)) {
const newKey = prefix ? `${prefix}${separator}${key}` : key
if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
Object.assign(flattened, flattenObject(value, newKey, separator))
} else {
flattened[newKey] = value
}
}
return flattened
}
const flattenCell = (value: any, col: string): Record<string, any> =>
value !== null && typeof value === 'object' && !Array.isArray(value) ? flattenObject(value, col) : { [col]: value }
// Returns one flattened group per column, so duplicate column names do not overwrite each other
const processRowData = (row: DataTableRow, columns: string[], query: DataTableNode): Record<string, any>[] => {
if (isHogQLQuery(query.source) || isMarketingAnalyticsTableQuery(query.source)) {
const data = row.result ?? {}
return columns.map((col, index) =>
flattenCell(Array.isArray(data) ? data[index] : (data as Record<string, any>)[index], col)
)
} else if (isEventsQuery(query.source) || isActorsQuery(query.source)) {
return columns.map((col, colIndex) => {
if (columnDisallowList.includes(col)) {
return {}
}
const value = Array.isArray(row.result)
? row.result[colIndex]
: (row.result as Record<string, any>)?.[colIndex]
const colName = extractExpressionComment(col)
if (col === 'person') {
return { [colName]: asDisplay(value) }
}
if (removeExpressionComment(col) === 'person_display_name') {
return { [colName]: value?.display_name }
}
return flattenCell(value, colName)
})
} else if (isPersonsNode(query.source)) {
const record = row.result as Record<string, any> | undefined
const recordWithPerson = { ...record, person: record?.name } as Record<string, any>
return columns.map((col) => (columnDisallowList.includes(col) ? {} : flattenCell(recordWithPerson[col], col)))
}
return []
}
export const getCsvTableData = (dataTableRows: DataTableRow[], columns: string[], query: DataTableNode): string[][] => {
// Handle empty data or unsupported query types
if (dataTableRows.length === 0) {
return []
}
const processedRows = dataTableRows.map((row) => processRowData(row, columns, query))
// Keep the query column order, and put flattened sub-columns right after their parent column
const groupKeys = columns.map((_, index) => {
const keys = new Set<string>()
processedRows.forEach((groups) => Object.keys(groups[index] ?? {}).forEach((key) => keys.add(key)))
return Array.from(keys)
})
const header = groupKeys.flat()
if (header.length === 0) {
return []
}
const csvData = processedRows.map((groups) =>
groupKeys.flatMap((keys, index) => keys.map((key) => groups[index]?.[key] ?? ''))
)
return [header, ...csvData]
}
export const getJsonTableData = (
dataTableRows: DataTableRow[],
columns: string[],
query: DataTableNode
): Record<string, any>[] => {
if (isPersonsNode(query.source)) {
const filteredColumns = columns.filter((n) => !columnDisallowList.includes(n))
return dataTableRows.map((n) => {
const record = n.result as Record<string, any> | undefined
const recordWithPerson = { ...record, person: record?.name } as Record<string, any>
return filteredColumns.reduce(
(acc, cur) => {
acc[cur] = recordWithPerson[cur]
return acc
},
{} as Record<string, any>
)
})
}
if (isEventsQuery(query.source)) {
return dataTableRows.map((n) => {
return columns.reduce(
(acc, col, colIndex) => {
if (columnDisallowList.includes(col)) {
return acc
}
if (col === 'person') {
acc[col] = asDisplay(
Array.isArray(n.result) ? n.result[colIndex] : (n.result as Record<string, any>)?.[colIndex]
)
return acc
}
const colName = extractExpressionComment(col)
acc[colName] = Array.isArray(n.result)
? n.result[colIndex]
: (n.result as Record<string, any>)?.[colIndex]
return acc
},
{} as Record<string, any>
)
})
}
if (isHogQLQuery(query.source) || isMarketingAnalyticsTableQuery(query.source)) {
return dataTableRows.map((n) => {
const data = n.result ?? {}
return columns.reduce(
(acc, cur, index) => {
acc[cur] = Array.isArray(data) ? data[index] : (data as Record<string, any>)[index]
return acc
},
{} as Record<string, any>
)
})
}
return []
}
export function copyTableToCsv(
dataTableRows: DataTableRow[],
columns: string[],
query: DataTableNode,
includeHeader: boolean = true
): void {
try {
const tableData = getCsvTableData(dataTableRows, columns, query).slice(includeHeader ? 0 : 1)
const csv = Papa.unparse(tableData)
void copyToClipboard(csv, 'table')
} catch {
lemonToast.error('Copy failed!')
}
}
export function copyTableToJson(dataTableRows: DataTableRow[], columns: string[], query: DataTableNode): void {
try {
const tableData = getJsonTableData(dataTableRows, columns, query)
const json = JSON.stringify(tableData, null, 4)
void copyToClipboard(json, 'table')
} catch {
lemonToast.error('Copy failed!')
}
}
export function copyTableToExcel(dataTableRows: DataTableRow[], columns: string[], query: DataTableNode): void {
try {
const tableData = getCsvTableData(dataTableRows, columns, query)
const tsv = Papa.unparse(tableData, { delimiter: '\t' })
void copyToClipboard(tsv, 'table')
} catch {
lemonToast.error('Copy failed!')
}
}
export function copyTableToMarkdown(dataTableRows: DataTableRow[], columns: string[], query: DataTableNode): void {
try {
const tableData = getCsvTableData(dataTableRows, columns, query)
if (tableData.length === 0) {
lemonToast.error('No data to copy!')
return
}
const [headers, ...rows] = tableData
const escape = (cell: any): string =>
String(cell ?? '')
.replace(/\n/g, '\\n')
.replace(/\r/g, '\\r')
.replace(/\|/g, '\\|')
const escapedHeaders = headers.map(escape)
const escapedRows = rows.map((row) => row.map(escape))
const colWidths = escapedHeaders.map((header, colIndex) =>
Math.max(3, header.length, ...escapedRows.map((row) => (row[colIndex] ?? '').length))
)
const pad = (cell: string, width: number): string => cell.padEnd(width)
const headerRow = `| ${escapedHeaders.map((h, i) => pad(h, colWidths[i])).join(' | ')} |`
const separatorRow = `| ${colWidths.map((w) => '-'.repeat(w)).join(' | ')} |`
const dataRows = escapedRows.map((row) => `| ${row.map((cell, i) => pad(cell, colWidths[i])).join(' | ')} |`)
const markdown = [headerRow, separatorRow, ...dataRows].join('\n')
void copyToClipboard(markdown, 'table')
} catch {
lemonToast.error('Copy failed!')
}
}