Skip to content

OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.

11.8 KB
Raw Blame
import type { IServiceSession } from '@openpanel/core';
import type { UseInfiniteQueryResult } from '@tanstack/react-query';
import { useNavigate } from '@tanstack/react-router';
import type { Table } from '@tanstack/react-table';
import { getCoreRowModel, useReactTable } from '@tanstack/react-table';
import { useWindowVirtualizer } from '@tanstack/react-virtual';
import type { TRPCInfiniteData } from '@trpc/tanstack-react-query';
import { Loader2Icon, RotateCwIcon, UsersIcon } from 'lucide-react';
import { last } from 'ramda';
import { memo, useCallback, useEffect, useMemo, useRef } from 'react';
import { useInViewport } from 'react-in-viewport';
import { useLocalStorage } from 'usehooks-ts';
import { useColumns } from './columns';
import { EmptyState } from '@/components/empty-state';
import { TableFilterPills } from '@/components/filters/TableFilterPills';
import { FullPageErrorState } from '@/components/full-page-error-state';
import { Skeleton } from '@/components/skeleton';
import { Button } from '@/components/ui/button';
import {
  AnimatedSearchInput,
  DataTableToolbarContainer,
} from '@/components/ui/data-table/data-table-toolbar';
import { DataTableViewOptions } from '@/components/ui/data-table/data-table-view-options';
import { useAppParams } from '@/hooks/use-app-params';
import { useSearchQueryState } from '@/hooks/use-search-query-state';
import type { RouterInputs, RouterOutputs } from '@/trpc/client';
import { cn } from '@/utils/cn';

// Custom hook for persistent column visibility
const usePersistentColumnVisibility = (columns: any[]) => {
  const [savedVisibility, setSavedVisibility] = useLocalStorage<
    Record<string, boolean>
  >('@op:sessions-table-column-visibility', {});

  // Create column visibility from saved state, defaulting to true (visible)
  const columnVisibility = useMemo(() => {
    return columns.reduce(
      (acc, column) => {
        const columnId = column.id || column.accessorKey;
        if (columnId) {
          acc[columnId] = savedVisibility[columnId] ?? true;
        }
        return acc;
      },
      {} as Record<string, boolean>
    );
  }, [columns, savedVisibility]);

  const handleColumnVisibilityChange = (updater: any) => {
    const newVisibility =
      typeof updater === 'function' ? updater(columnVisibility) : updater;
    setSavedVisibility(newVisibility);
  };

  return {
    columnVisibility,
    setColumnVisibility: handleColumnVisibilityChange,
  };
};

interface Props {
  query: UseInfiniteQueryResult<
    TRPCInfiniteData<
      RouterInputs['session']['list'],
      RouterOutputs['session']['list']
    >,
    unknown
  >;
}

const LOADING_DATA = [{}, {}, {}, {}, {}, {}, {}, {}, {}] as IServiceSession[];
const ROW_HEIGHT = 40;

interface VirtualizedSessionsTableProps {
  table: Table<IServiceSession>;
  data: IServiceSession[];
  isLoading: boolean;
}

interface VirtualRowProps {
  row: any;
  virtualRow: any;
  headerColumns: any[];
  scrollMargin: number;
  isLoading: boolean;
  headerColumnsHash: string;
  onRowClick?: (row: any) => void;
}

const VirtualRow = memo(
  function VirtualRow({
    row,
    virtualRow,
    headerColumns,
    scrollMargin,
    isLoading,
    onRowClick,
  }: VirtualRowProps) {
    return (
      <div
        className={cn(
          'group/row absolute top-0 left-0 w-full border-b transition-colors hover:bg-muted/50',
          onRowClick && 'cursor-pointer'
        )}
        data-index={virtualRow.index}
        onClick={
          onRowClick
            ? (e) => {
                if ((e.target as HTMLElement).closest('a, button')) {
                  return;
                }
                onRowClick(row);
              }
            : undefined
        }
        ref={virtualRow.measureElement}
        style={{
          transform: `translateY(${virtualRow.start - scrollMargin}px)`,
          display: 'grid',
          gridTemplateColumns: headerColumns
            .map((col) => `${col.getSize()}px`)
            .join(' '),
          minWidth: 'fit-content',
          minHeight: ROW_HEIGHT,
        }}
      >
        {row.getVisibleCells().map((cell: any) => {
          const width = `${cell.column.getSize()}px`;
          return (
            <div
              className="flex items-center whitespace-nowrap p-2 px-4 align-middle"
              key={cell.id}
              style={{
                width,
                overflow: 'hidden',
              }}
            >
              {isLoading ? (
                <Skeleton className="h-4 w-3/5" />
              ) : cell.column.columnDef.cell ? (
                typeof cell.column.columnDef.cell === 'function' ? (
                  cell.column.columnDef.cell(cell.getContext())
                ) : (
                  cell.column.columnDef.cell
                )
              ) : (
                (cell.getValue() as React.ReactNode)
              )}
            </div>
          );
        })}
      </div>
    );
  },
  (prevProps, nextProps) => {
    return (
      prevProps.row.id === nextProps.row.id &&
      prevProps.virtualRow.index === nextProps.virtualRow.index &&
      prevProps.virtualRow.start === nextProps.virtualRow.start &&
      prevProps.virtualRow.size === nextProps.virtualRow.size &&
      prevProps.isLoading === nextProps.isLoading &&
      prevProps.headerColumnsHash === nextProps.headerColumnsHash &&
      prevProps.onRowClick === nextProps.onRowClick
    );
  }
);

const VirtualizedSessionsTable = ({
  table,
  data,
  isLoading,
  onRowClick,
}: VirtualizedSessionsTableProps & { onRowClick?: (row: any) => void }) => {
  const parentRef = useRef<HTMLDivElement>(null);

  const headerColumns = table.getAllLeafColumns().filter((col) => {
    return table.getState().columnVisibility[col.id] !== false;
  });

  const rowVirtualizer = useWindowVirtualizer({
    count: data.length,
    estimateSize: () => ROW_HEIGHT, // Estimated row height
    overscan: 10,
    scrollMargin: parentRef.current?.offsetTop ?? 0,
    // Key cache entries by row id so when filters refetch and the data
    // array changes, the virtualizer doesn't reuse stale per-index
    // measurements (which produces overlapping rows).
    getItemKey: (index) => data[index]?.id ?? index,
  });

  const virtualRows = rowVirtualizer.getVirtualItems();
  const headerColumnsHash = headerColumns.map((col) => col.id).join(',');

  return (
    <div
      className="w-full overflow-x-auto rounded-md border bg-card"
      ref={parentRef}
    >
      <div
        className="sticky top-0 z-10 border-b bg-card"
        style={{
          display: 'grid',
          gridTemplateColumns: headerColumns
            .map((col) => `${col.getSize()}px`)
            .join(' '),
          minWidth: 'fit-content',
        }}
      >
        {headerColumns.map((column) => {
          const header = column.columnDef.header;
          const width = `${column.getSize()}px`;
          return (
            <div
              className="flex h-10 items-center whitespace-nowrap px-4 text-left font-semibold text-3xs text-foreground uppercase"
              key={column.id}
              style={{
                width,
              }}
            >
              {typeof header === 'function' ? header({} as any) : header}
            </div>
          );
        })}
      </div>

      {!isLoading && data.length === 0 && (
        <EmptyState
          className="py-16"
          description="Nothing matches this date range and filters. Sessions appear as soon as your site or app sends events."
          icon={UsersIcon}
          title="No sessions"
          variant="inline"
        />
      )}

      <div
        className="relative w-full"
        style={{
          height: `${rowVirtualizer.getTotalSize()}px`,
          minHeight: 'fit-content',
          minWidth: 'fit-content',
        }}
      >
        {virtualRows.map((virtualRow) => {
          const row = table.getRowModel().rows[virtualRow.index];
          if (!row) {
            return null;
          }

          return (
            <VirtualRow
              headerColumns={headerColumns}
              headerColumnsHash={headerColumnsHash}
              isLoading={isLoading}
              key={row.id}
              onRowClick={onRowClick}
              row={row}
              scrollMargin={rowVirtualizer.options.scrollMargin}
              virtualRow={{
                ...virtualRow,
                measureElement: rowVirtualizer.measureElement,
              }}
            />
          );
        })}
      </div>
    </div>
  );
};

export const SessionsTable = ({ query }: Props) => {
  const { isLoading } = query;
  const columns = useColumns();
  const navigate = useNavigate();
  const { organizationId, projectId } = useAppParams();

  const handleRowClick = useCallback(
    (row: any) => {
      navigate({
        to: '/$organizationId/$projectId/sessions/$sessionId',
        params: { organizationId, projectId, sessionId: row.original.id },
      });
    },
    [navigate, organizationId, projectId]
  );

  const data = useMemo(() => {
    if (isLoading) {
      return LOADING_DATA;
    }

    return query.data?.pages?.flatMap((p) => p.items) ?? [];
  }, [query.data, isLoading]);

  const { columnVisibility, setColumnVisibility } =
    usePersistentColumnVisibility(columns);

  const table = useReactTable({
    data,
    getCoreRowModel: getCoreRowModel(),
    manualPagination: true,
    manualFiltering: true,
    manualSorting: true,
    columns,
    rowCount: 50,
    pageCount: 1,
    filterFns: {
      isWithinRange: () => true,
    },
    state: {
      columnVisibility,
    },
    onColumnVisibilityChange: setColumnVisibility,
    getRowId: (row, index) => row.id ?? `loading-${index}`,
  });

  const inViewportRef = useRef<HTMLDivElement>(null);
  const { inViewport, enterCount } = useInViewport(inViewportRef, undefined, {
    disconnectOnLeave: true,
  });

  const hasNextPage = last(query.data?.pages ?? [])?.meta.next;

  useEffect(() => {
    if (
      hasNextPage &&
      data.length > 0 &&
      inViewport &&
      enterCount > 0 &&
      query.isFetchingNextPage === false
    ) {
      query.fetchNextPage();
    }
  }, [inViewport, enterCount, hasNextPage]);

  const hasFailedWithoutData = query.isError && !query.data;
  if (hasFailedWithoutData) {
    return (
      <>
        <SessionTableToolbar table={table} />
        <FullPageErrorState
          description="We could not load this data. Try again in a moment."
          title="Something went wrong"
          variant="inline"
        >
          <Button
            icon={RotateCwIcon}
            loading={query.isFetching}
            onClick={() => query.refetch()}
            variant="outline"
          >
            Try again
          </Button>
        </FullPageErrorState>
      </>
    );
  }

  return (
    <>
      <SessionTableToolbar table={table} />
      <VirtualizedSessionsTable
        data={data}
        isLoading={isLoading}
        onRowClick={handleRowClick}
        table={table}
      />
      <div className="center-center h-10 w-full pt-4" ref={inViewportRef}>
        <div
          className={cn(
            'center-center size-8 rounded-full border bg-background opacity-0 transition-opacity',
            query.isFetchingNextPage && 'opacity-100'
          )}
        >
          <Loader2Icon className="size-4 animate-spin" />
        </div>
      </div>
    </>
  );
};

function SessionTableToolbar({ table }: { table: Table<IServiceSession> }) {
  const { search, setSearch } = useSearchQueryState();

  return (
    <DataTableToolbarContainer>
      <div className="flex flex-1 flex-wrap items-center gap-2">
        <AnimatedSearchInput
          onChange={setSearch}
          placeholder="Search sessions by path, referrer..."
          value={search}
        />
        <TableFilterPills
          categories={['profile', 'group', 'cohort', 'session']}
          title="Session filters"
          urlKey="f"
        />
      </div>
      <DataTableViewOptions table={table} />
    </DataTableToolbarContainer>
  );
}