Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

Pages (#284)

Bill Yanga4a285e1ca45
diff --git a/client/src/api/analytics/useGetOverviewBucketed.ts b/client/src/api/analytics/useGetOverviewBucketed.ts
index aef585219..99b033e2f 100644
--- a/client/src/api/analytics/useGetOverviewBucketed.ts
+++ b/client/src/api/analytics/useGetOverviewBucketed.ts
@@ -4,7 +4,7 @@ import {
useQuery,
} from "@tanstack/react-query";
import { BACKEND_URL } from "../../lib/const";
-import { TimeBucket, useStore } from "../../lib/store";
+import { Filter, TimeBucket, useStore } from "../../lib/store";
import { timeZone } from "../../lib/dateTimeUtils";
import { APIResponse } from "../types";
import { authedFetch, getStartAndEndDate } from "../utils";
@@ -25,34 +25,43 @@ export function useGetOverviewBucketed({
periodTime,
site,
bucket = "hour",
+ dynamicFilters = [],
props,
}: {
periodTime?: PeriodTime;
- site?: number | string;
+ site: number | string;
bucket?: TimeBucket;
+ dynamicFilters?: Filter[];
props?: Partial<UseQueryOptions<APIResponse<GetOverviewBucketedResponse>>>;
}): UseQueryResult<APIResponse<GetOverviewBucketedResponse>> {
- const { time, previousTime, filters } = useStore();
+ const { time, previousTime, filters: globalFilters } = useStore();
const timeToUse = periodTime === "previous" ? previousTime : time;
const { startDate, endDate } = getStartAndEndDate(timeToUse);
+ const combinedFilters = [...globalFilters, ...dynamicFilters];
+
return useQuery({
- queryKey: ["overview-bucketed", timeToUse, bucket, site, filters],
+ queryKey: ["overview-bucketed", timeToUse, bucket, site, combinedFilters],
queryFn: () => {
return authedFetch(`${BACKEND_URL}/overview-bucketed/${site}`, {
startDate,
endDate,
timeZone,
bucket,
- filters,
+ filters: combinedFilters,
}).then((res) => res.json());
},
placeholderData: (_, query: any) => {
if (!query?.queryKey) return undefined;
- const prevQueryKey = query.queryKey as [string, string, string];
- const [, , prevSite] = prevQueryKey;
+ const [, , , prevSite] = query.queryKey as [
+ string,
+ any,
+ TimeBucket,
+ string | number,
+ Filter[]
+ ];
if (prevSite === site) {
return query.state.data;
@@ -71,19 +80,22 @@ export function useGetOverviewBucketedPastMinutes({
site,
bucket = "hour",
refetchInterval,
+ dynamicFilters = [],
props,
}: {
pastMinutes?: number;
pastMinutesStart?: number;
pastMinutesEnd?: number;
- site?: number | string;
+ site: number | string;
bucket?: TimeBucket;
refetchInterval?: number;
+ dynamicFilters?: Filter[];
props?: Partial<UseQueryOptions<APIResponse<GetOverviewBucketedResponse>>>;
}): UseQueryResult<APIResponse<GetOverviewBucketedResponse>> {
- const { filters } = useStore();
+ const { filters: globalFilters } = useStore();
+
+ const combinedFilters = [...globalFilters, ...dynamicFilters];
- // Determine if we're using a specific range or just pastMinutes
const useRange =
pastMinutesStart !== undefined && pastMinutesEnd !== undefined;
@@ -95,9 +107,15 @@ export function useGetOverviewBucketedPastMinutes({
pastMinutesEnd,
site,
bucket,
- filters,
+ combinedFilters,
]
- : ["overview-bucketed-past-minutes", pastMinutes, site, bucket, filters],
+ : [
+ "overview-bucketed-past-minutes",
+ pastMinutes,
+ site,
+ bucket,
+ combinedFilters,
+ ],
queryFn: () => {
return authedFetch(
`${BACKEND_URL}/overview-bucketed/${site}`,
@@ -107,22 +125,26 @@ export function useGetOverviewBucketedPastMinutes({
bucket,
pastMinutesStart,
pastMinutesEnd,
- filters,
+ filters: combinedFilters,
}
: {
timeZone,
bucket,
pastMinutes,
- filters,
+ filters: combinedFilters,
}
).then((res) => res.json());
},
refetchInterval,
placeholderData: (_, query: any) => {
if (!query?.queryKey) return undefined;
- const prevQueryKey = query.queryKey as [string, string, string];
- const [, , prevSite] = prevQueryKey;
-
+ const [, , prevSite] = query.queryKey as [
+ string,
+ any,
+ string | number,
+ TimeBucket,
+ Filter[]
+ ];
if (prevSite === site) {
return query.state.data;
}
@@ -141,45 +163,52 @@ export function useGetOverviewBucketedPreviousPastMinutes({
site,
bucket = "hour",
refetchInterval,
+ dynamicFilters = [],
props,
}: {
pastMinutes?: number;
- site?: number | string;
+ site: number | string;
bucket?: TimeBucket;
refetchInterval?: number;
+ dynamicFilters?: Filter[];
props?: Partial<UseQueryOptions<APIResponse<GetOverviewBucketedResponse>>>;
}): UseQueryResult<APIResponse<GetOverviewBucketedResponse>> {
- const { filters } = useStore();
+ const { filters: globalFilters } = useStore();
+
+ const combinedFilters = [...globalFilters, ...dynamicFilters];
- // For the previous period, we use the pastMinutesStart/End approach
- // If pastMinutes is 24 * 60 (24 hours), then we fetch 24-48 hour data
- const pastMinutesStart = pastMinutes * 2; // e.g., 48 hours ago
- const pastMinutesEnd = pastMinutes; // e.g., 24 hours ago
+ const pastMinutesStartVal = pastMinutes * 2;
+ const pastMinutesEndVal = pastMinutes;
return useQuery({
queryKey: [
"overview-bucketed-previous-past-minutes",
- pastMinutesStart,
- pastMinutesEnd,
+ pastMinutesStartVal,
+ pastMinutesEndVal,
site,
bucket,
- filters,
+ combinedFilters,
],
queryFn: () => {
return authedFetch(`${BACKEND_URL}/overview-bucketed/${site}`, {
timeZone,
bucket,
- pastMinutesStart,
- pastMinutesEnd,
- filters,
+ pastMinutesStart: pastMinutesStartVal,
+ pastMinutesEnd: pastMinutesEndVal,
+ filters: combinedFilters,
}).then((res) => res.json());
},
refetchInterval,
placeholderData: (_, query: any) => {
if (!query?.queryKey) return undefined;
- const prevQueryKey = query.queryKey as [string, string, string];
- const [, , prevSite] = prevQueryKey;
-
+ const [, , , prevSite] = query.queryKey as [
+ string,
+ number,
+ number,
+ string | number,
+ TimeBucket,
+ Filter[]
+ ];
if (prevSite === site) {
return query.state.data;
}
diff --git a/client/src/api/analytics/useGetPageTitles.ts b/client/src/api/analytics/useGetPageTitles.ts
new file mode 100644
index 000000000..15e552a29
--- /dev/null
+++ b/client/src/api/analytics/useGetPageTitles.ts
@@ -0,0 +1,86 @@
+import { useQuery, UseQueryResult } from "@tanstack/react-query";
+import { FilterParameter, useStore } from "@/lib/store";
+import { timeZone } from "@/lib/dateTimeUtils";
+import { APIResponse } from "../types";
+import { BACKEND_URL } from "@/lib/const";
+import { getStartAndEndDate, authedFetch } from "../utils";
+
+// This should match PageTitleItem from the backend
+export type PageTitleItem = {
+ value: string; // The page_title
+ pathname: string; // A representative pathname
+ count: number;
+ percentage: number;
+ // Add other potential fields if your backend query for page_titles includes them
+};
+
+// This should match the paginated response structure from getPageTitles.ts
+export type PageTitlesPaginatedResponse = {
+ data: PageTitleItem[];
+ totalCount: number;
+};
+
+// This is for non-paginated use by StandardSection (or similar)
+// It directly expects an array of PageTitleItem ype PageTitlesStandardResponse = PageTitleItem[];
+export type PageTitlesStandardResponse = PageTitleItem[];
+
+type UseGetPageTitlesOptions = {
+ limit?: number;
+ offset?: number;
+ useFilters?: boolean;
+ // No specific 'parameter' needed as this hook is for page_titles
+};
+
+// Hook for paginated fetching (e.g., for a dedicated "All Page Titles" screen)
+export function useGetPageTitlesPaginated({
+ limit = 10,
+ offset = 0,
+ useFilters = true,
+}: UseGetPageTitlesOptions): UseQueryResult<
+ APIResponse<PageTitlesPaginatedResponse>
+> {
+ const { time, site, filters } = useStore();
+
+ // Check if we're using last-24-hours mode
+ const isPast24HoursMode = time.mode === "last-24-hours";
+
+ // Determine the query parameters based on mode
+ const queryParams = isPast24HoursMode
+ ? {
+ // Past minutes approach for last-24-hours mode
+ timeZone: timeZone,
+ minutes: 24 * 60, // 24 hours in minutes
+ limit,
+ offset,
+ filters: useFilters ? filters : undefined,
+ }
+ : {
+ // Regular date-based approach
+ ...getStartAndEndDate(time),
+ timeZone: timeZone,
+ limit,
+ offset,
+ filters: useFilters ? filters : undefined,
+ };
+
+ return useQuery({
+ queryKey: [
+ "page-titles",
+ time,
+ site,
+ filters,
+ limit,
+ offset,
+ isPast24HoursMode ? "past-minutes" : "date-range",
+ ],
+ queryFn: () => {
+ return authedFetch(
+ `${BACKEND_URL}/page-titles/${site}`,
+ queryParams
+ ).then(
+ (res: any) => res.json() // Added any type for res
+ );
+ },
+ staleTime: Infinity,
+ });
+}
diff --git a/client/src/api/analytics/usePaginatedSingleCol.ts b/client/src/api/analytics/usePaginatedSingleCol.ts
new file mode 100644
index 000000000..2a0af7d7d
--- /dev/null
+++ b/client/src/api/analytics/usePaginatedSingleCol.ts
@@ -0,0 +1,69 @@
+import { useQuery, UseQueryResult } from "@tanstack/react-query";
+import { FilterParameter, useStore } from "@/lib/store";
+import { timeZone } from "@/lib/dateTimeUtils";
+import { APIResponse } from "@/api/types";
+import { BACKEND_URL } from "@/lib/const";
+import { getStartAndEndDate, authedFetch } from "@/api/utils";
+import { SingleColResponse } from "@/api/analytics/useSingleCol";
+
+type UsePaginatedSingleColOptions = {
+ parameter: FilterParameter;
+ limit?: number;
+ offset?: number;
+ useFilters?: boolean;
+};
+
+// Reverted: Backend will now return this structure inside APIResponse.data
+type PaginatedResponse = {
+ data: SingleColResponse[];
+ totalCount: number;
+};
+
+export function usePaginatedSingleCol({
+ parameter,
+ limit = 10,
+ offset = 0,
+ useFilters = true,
+}: UsePaginatedSingleColOptions): UseQueryResult<
+ APIResponse<PaginatedResponse> // Adjusted return type back
+> {
+ const { time, site, filters } = useStore();
+
+ // Determine the query parameters based on mode
+ const queryParams = {
+ ...getStartAndEndDate(time),
+ timeZone: timeZone,
+ parameter,
+ limit,
+ offset,
+ filters: useFilters ? filters : undefined,
+ };
+
+ return useQuery({
+ queryKey: [
+ parameter,
+ time,
+ site,
+ filters,
+ limit,
+ offset,
+ "paginated-single-col",
+ ], // More specific key
+ queryFn: () => {
+ return authedFetch(`${BACKEND_URL}/single-col/${site}`, queryParams).then(
+ (res) => res.json()
+ );
+ },
+ staleTime: Infinity,
+ placeholderData: (_, query: any) => {
+ if (!query?.queryKey) return undefined;
+ const prevQueryKey = query.queryKey;
+ const [, , prevSite] = prevQueryKey;
+
+ if (prevSite === site) {
+ return query.state.data;
+ }
+ return undefined;
+ },
+ });
+}
diff --git a/client/src/api/usePageMetadata.ts b/client/src/api/usePageMetadata.ts
new file mode 100644
index 000000000..54b2ce722
--- /dev/null
+++ b/client/src/api/usePageMetadata.ts
@@ -0,0 +1,52 @@
+import { useQuery } from "@tanstack/react-query";
+
+interface PageMetadata {
+ title?: string;
+ description?: string;
+ image?: string;
+ url?: string;
+ siteName?: string;
+ favicon?: string;
+}
+
+export function usePageMetadata(pageUrl: string | null) {
+ return useQuery({
+ queryKey: ["page-metadata", pageUrl],
+ queryFn: async (): Promise<PageMetadata> => {
+ if (!pageUrl) {
+ return {};
+ }
+
+ try {
+ // Using Microlink to fetch metadata
+ const response = await fetch(
+ `https://api.microlink.io/?url=${encodeURIComponent(
+ pageUrl
+ )}&meta=true&screenshot=false`
+ );
+
+ if (!response.ok) {
+ throw new Error(`Failed to fetch metadata: ${response.statusText}`);
+ }
+
+ const data = await response.json();
+
+ // Extract relevant metadata
+ return {
+ title: data.data?.title,
+ description: data.data?.description,
+ image: data.data?.ogImage?.url || data.data?.image?.url,
+ url: data.data?.url,
+ siteName: data.data?.publisher,
+ favicon: data.data?.logo?.url,
+ };
+ } catch (error) {
+ console.error("Error fetching page metadata:", error);
+ throw error;
+ }
+ },
+ enabled: !!pageUrl, // Only run the query if pageUrl is provided
+ staleTime: 24 * 60 * 60 * 1000, // Cache for 24 hours
+ retry: 1, // Only retry once if failed
+ });
+}
diff --git a/client/src/app/[site]/components/Sidebar/Sidebar.tsx b/client/src/app/[site]/components/Sidebar/Sidebar.tsx
index e452b61dd..4e0d90ac1 100644
--- a/client/src/app/[site]/components/Sidebar/Sidebar.tsx
+++ b/client/src/app/[site]/components/Sidebar/Sidebar.tsx
@@ -9,7 +9,8 @@ import {
Rewind,
Settings,
Split,
- User
+ User,
+ File,
} from "lucide-react";
import Link from "next/link";
import { usePathname } from "next/navigation";
@@ -53,6 +54,12 @@ export function Sidebar() {
href={getTabPath("main")}
icon={<LayoutDashboard className="w-4 h-4" />}
/>
+ <SidebarLink
+ label="Pages"
+ active={isActiveTab("pages")}
+ href={getTabPath("pages")}
+ icon={<File className="w-4 h-4" />}
+ />
<SidebarLink
label="Realtime"
active={isActiveTab("realtime")}
@@ -145,7 +152,14 @@ function SidebarLink({
}) {
return (
<Link href={href} className="focus:outline-none">
- <div className={cn("px-3 py-2 rounded-lg transition-colors w-full", active ? "bg-neutral-800 text-white" : "text-neutral-200 hover:text-white hover:bg-neutral-800/50")}>
+ <div
+ className={cn(
+ "px-3 py-2 rounded-lg transition-colors w-full",
+ active
+ ? "bg-neutral-800 text-white"
+ : "text-neutral-200 hover:text-white hover:bg-neutral-800/50"
+ )}
+ >
<div className="flex items-center gap-2">
{icon}
<span className="text-sm">{label}</span>
diff --git a/client/src/app/[site]/main/components/sections/Pages.tsx b/client/src/app/[site]/main/components/sections/Pages.tsx
index a95e93a8a..bcb5e6ed5 100644
--- a/client/src/app/[site]/main/components/sections/Pages.tsx
+++ b/client/src/app/[site]/main/components/sections/Pages.tsx
@@ -1,18 +1,19 @@
"use client";
+import { useStore } from "@/lib/store";
+import { Expand } from "lucide-react";
import { useState } from "react";
+import { useGetSite } from "../../../../../api/admin/sites";
import {
Tabs,
TabsContent,
TabsList,
TabsTrigger,
} from "../../../../../components/ui/basic-tabs";
+import { Button } from "../../../../../components/ui/button";
import { Card, CardContent } from "../../../../../components/ui/card";
-import { StandardSection } from "../../../components/shared/StandardSection/StandardSection";
-import { useGetSite } from "../../../../../api/admin/sites";
import { truncateString } from "../../../../../lib/utils";
-import { Button } from "../../../../../components/ui/button";
-import { Expand } from "lucide-react";
+import { StandardSection } from "../../../components/shared/StandardSection/StandardSection";
type Tab = "pages" | "page_title" | "entry_pages" | "exit_pages";
@@ -61,14 +62,18 @@ export function Pages() {
</TabsContent>
<TabsContent value="page_title">
<StandardSection
- filterParameter="pathname"
+ filterParameter="page_title"
title="Page Title"
getValue={(e) => e.value}
getKey={(e) => e.value}
getLabel={(e) =>
- truncateString(e?.title ?? "", MAX_LABEL_LENGTH) || "Other"
+ truncateString(e.value, MAX_LABEL_LENGTH) || "Other"
}
- getLink={(e) => `https://${siteMetadata?.domain}${e.value}`}
+ // getLink={(e) =>
+ // e.pathname
+ // ? `https://${siteMetadata?.domain}${e.pathname}`
+ // : "#"
+ // }
expanded={expanded}
close={close}
/>
@@ -80,7 +85,7 @@ export function Pages() {
getValue={(e) => e.value}
getKey={(e) => e.value}
getLabel={(e) =>
- truncateString(e?.title ?? "", MAX_LABEL_LENGTH) || "Other"
+ truncateString(e.value, MAX_LABEL_LENGTH) || "Other"
}
getLink={(e) => `https://${siteMetadata?.domain}${e.value}`}
expanded={expanded}
diff --git a/client/src/app/[site]/pages/components/PageListItem.tsx b/client/src/app/[site]/pages/components/PageListItem.tsx
new file mode 100644
index 000000000..e396e90e4
--- /dev/null
+++ b/client/src/app/[site]/pages/components/PageListItem.tsx
@@ -0,0 +1,164 @@
+"use client";
+
+import { useGetSite } from "@/api/admin/sites";
+import {
+ useGetOverviewBucketed,
+ useGetOverviewBucketedPastMinutes,
+} from "@/api/analytics/useGetOverviewBucketed";
+import { SingleColResponse } from "@/api/analytics/useSingleCol";
+import { usePageMetadata } from "@/api/usePageMetadata";
+import { Card, CardContent } from "@/components/ui/card";
+import { Filter, useStore } from "@/lib/store";
+import { truncateString } from "@/lib/utils";
+import { ExternalLink } from "lucide-react";
+import Link from "next/link";
+import { useState } from "react";
+import { PageSparklineChart } from "./PageSparklineChart";
+
+// Maximum length for page titles
+const MAX_TITLE_LENGTH = 70;
+
+type PageListItemProps = {
+ pageData: SingleColResponse;
+ isLoading?: boolean;
+};
+
+export function PageListItem({
+ pageData,
+ isLoading = false,
+}: PageListItemProps) {
+ const [isHovering, setIsHovering] = useState(false);
+ const [thumbnailError, setThumbnailError] = useState(false);
+ const { data: siteMetadata } = useGetSite();
+ const { site, time, bucket } = useStore(); // Get time and bucket from store
+
+ const isPast24HoursMode = time.mode === "last-24-hours";
+
+ // Create a pathname filter for this specific page
+ const pageSpecificFilter: Filter = {
+ parameter: "page_title",
+ value: [pageData.title ?? ""],
+ type: "equals",
+ };
+
+ // Regular bucketed data for sparklines
+ const { data: regularData, isLoading: isLoadingRegular } =
+ useGetOverviewBucketed({
+ site,
+ bucket,
+ dynamicFilters: [pageSpecificFilter],
+ props: {
+ enabled: !isPast24HoursMode,
+ },
+ });
+
+ // Past minutes data for sparklines
+ const { data: pastMinutesData, isLoading: isLoadingPastMinutes } =
+ useGetOverviewBucketedPastMinutes({
+ pastMinutes: 24 * 60,
+ site,
+ bucket,
+ dynamicFilters: [pageSpecificFilter],
+ props: {
+ enabled: isPast24HoursMode,
+ },
+ });
+
+ // Use the appropriate data source based on mode
+ const pageTrafficData = isPast24HoursMode ? pastMinutesData : regularData;
+ const isLoadingTrafficData = isPast24HoursMode
+ ? isLoadingPastMinutes
+ : isLoadingRegular;
+
+ // External URL for the page
+ const pageUrl = siteMetadata?.domain
+ ? `https://${siteMetadata.domain}${pageData.value}`
+ : "";
+
+ // Fetch page metadata using TanStack Query
+ const {
+ data: metadata,
+ isLoading: isLoadingMetadata,
+ isError: isMetadataError,
+ } = usePageMetadata(pageUrl);
+
+ // Get thumbnail URL from metadata
+ const thumbnailUrl =
+ !thumbnailError && !isMetadataError ? metadata?.image : null;
+
+ // Handle image error
+ const handleImageError = () => {
+ setThumbnailError(true);
+ };
+
+ return (
+ <Card
+ className="w-full mb-3"
+ onMouseEnter={() => setIsHovering(true)}
+ onMouseLeave={() => setIsHovering(false)}
+ >
+ <CardContent className="p-4">
+ <div className="flex flex-col md:flex-row justify-between items-start md:items-center w-full gap-4">
+ {/* Left side: Page title/path with thumbnail */}
+ <div className="flex gap-3 flex-1 min-w-0">
+ {thumbnailUrl && !isLoadingMetadata && (
+ <div className="hidden sm:block flex-shrink-0 h-16 w-24 relative rounded-md overflow-hidden border border-neutral-800">
+ <img
+ src={thumbnailUrl}
+ alt={`Thumbnail for ${pageData.title || pageData.value}`}
+ className="w-full h-full object-cover"
+ onError={handleImageError}
+ />
+ </div>
+ )}
+
+ <div className="flex-1 min-w-0">
+ <div className="flex items-center gap-2">
+ <h3 className="text-lg font-medium truncate">
+ {truncateString(
+ pageData.title || pageData.value,
+ MAX_TITLE_LENGTH
+ )}
+ </h3>
+ {pageUrl && (
+ <Link
+ href={pageUrl}
+ target="_blank"
+ rel="noopener noreferrer"
+ className="text-muted-foreground hover:text-primary"
+ >
+ <ExternalLink className="h-4 w-4" />
+ </Link>
+ )}
+ </div>
+ <p className="text-sm text-muted-foreground truncate">
+ {pageData.value}
+ </p>
+ </div>
+ </div>
+
+ {/* Right side: Sparkline chart and session count */}
+ <div className="flex items-center gap-6 w-full md:w-auto">
+ {/* Sparkline chart */}
+ <div className="h-16 w-48">
+ <PageSparklineChart
+ data={pageTrafficData}
+ isHovering={isHovering}
+ pageTitle={pageData.title || pageData.value}
+ isLoading={isLoadingTrafficData}
+ />
+ </div>
+
+ {/* Session count */}
+ <div className="text-right min-w-[80px]">
+ <div className="text-xl font-semibold">
+ {pageData.count.toLocaleString()}
+ </div>
+ <div className="text-xs text-muted-foreground">sessions</div>
+ </div>
+ </div>
+ </div>
+ </CardContent>
+ </Card>
+ );
+}
diff --git a/client/src/app/[site]/pages/components/PageListSkeleton.tsx b/client/src/app/[site]/pages/components/PageListSkeleton.tsx
new file mode 100644
index 000000000..5c5667849
--- /dev/null
+++ b/client/src/app/[site]/pages/components/PageListSkeleton.tsx
@@ -0,0 +1,40 @@
+"use client";
+
+import { Card, CardContent } from "@/components/ui/card";
+import { Skeleton } from "@/components/ui/skeleton";
+
+type PageListSkeletonProps = {
+ count?: number;
+};
+
+export function PageListSkeleton({ count = 5 }: PageListSkeletonProps) {
+ return (
+ <>
+ {Array.from({ length: count }).map((_, index) => (
+ <Card key={index} className="w-full mb-3">
+ <CardContent className="p-4">
+ <div className="flex flex-col md:flex-row justify-between items-start md:items-center w-full gap-4">
+ {/* Left side: Page title/path skeleton */}
+ <div className="flex-1 min-w-0">
+ <Skeleton className="h-6 w-64 mb-2" />
+ <Skeleton className="h-4 w-48" />
+ </div>
+
+ {/* Right side: Sparkline and count skeleton */}
+ <div className="flex items-center gap-6 w-full md:w-auto">
+ {/* Sparkline chart placeholder */}
+ <Skeleton className="h-16 w-48 rounded-md" />
+
+ {/* Session count placeholder */}
+ <div className="text-right min-w-[80px]">
+ <Skeleton className="h-8 w-20 mb-1" />
+ <Skeleton className="h-4 w-16 ml-auto" />
+ </div>
+ </div>
+ </div>
+ </CardContent>
+ </Card>
+ ))}
+ </>
+ );
+}
diff --git a/client/src/app/[site]/pages/components/PageSparklineChart.tsx b/client/src/app/[site]/pages/components/PageSparklineChart.tsx
new file mode 100644
index 000000000..0b5091ca4
--- /dev/null
+++ b/client/src/app/[site]/pages/components/PageSparklineChart.tsx
@@ -0,0 +1,129 @@
+"use client";
+
+import { GetOverviewBucketedResponse } from "@/api/analytics/useGetOverviewBucketed";
+import { APIResponse } from "@/api/types";
+import { hour12, userLocale } from "@/lib/dateTimeUtils";
+import { nivoTheme } from "@/lib/nivo";
+import { ResponsiveLine } from "@nivo/line";
+import { DateTime } from "luxon";
+
+interface PageSparklineChartProps {
+ data: APIResponse<GetOverviewBucketedResponse> | undefined;
+ isHovering: boolean;
+ pageTitle: string;
+ isLoading: boolean;
+}
+
+export function PageSparklineChart({
+ data,
+ isHovering,
+ pageTitle,
+ isLoading,
+}: PageSparklineChartProps) {
+ if (isLoading) {
+ return (
+ <div className="h-full w-full flex items-center justify-center animate-pulse">
+ <div className="h-[1px] w-full bg-border opacity-50"></div>
+ </div>
+ );
+ }
+
+ // Format the chart data
+ const sparklineData = data?.data
+ ?.filter((e) => {
+ // Filter out dates from the future
+ return DateTime.fromSQL(e.time).toUTC() <= DateTime.now();
+ })
+ .map((e) => ({
+ x: DateTime.fromSQL(e.time).toUTC().toFormat("yyyy-MM-dd HH:mm:ss"),
+ y: e.sessions || 0,
+ time: DateTime.fromSQL(e.time).toUTC(),
+ }));
+
+ if (!sparklineData || sparklineData.length === 0) {
+ return (
+ <div className="h-full w-full flex items-center justify-center">
+ <div className="h-[1px] w-full bg-border opacity-50"></div>
+ </div>
+ );
+ }
+
+ return (
+ <ResponsiveLine
+ data={[{ id: pageTitle, data: sparklineData }]}
+ theme={nivoTheme}
+ margin={{ top: 5, right: 0, bottom: 0, left: 0 }}
+ xScale={{
+ type: "time",
+ format: "%Y-%m-%d %H:%M:%S",
+ precision: "second",
+ useUTC: true,
+ }}
+ yScale={{
+ type: "linear",
+ min: 0,
+ stacked: false,
+ reverse: false,
+ }}
+ enableGridX={false}
+ enableGridY={false}
+ axisTop={null}
+ axisRight={null}
+ axisBottom={null}
+ axisLeft={null}
+ enableTouchCrosshair={true}
+ enablePoints={false}
+ useMesh={true}
+ animate={false}
+ enableSlices={"x"}
+ colors={[isHovering ? "hsl(var(--dataviz-2))" : "hsl(var(--dataviz))"]}
+ enableArea={true}
+ areaBaselineValue={0}
+ areaOpacity={0.3}
+ curve="linear"
+ defs={[
+ {
+ id: "gradient",
+ type: "linearGradient",
+ colors: [
+ { offset: 0, color: "hsl(var(--dataviz))", opacity: 1 },
+ {
+ offset: 100,
+ color: "hsl(var(--dataviz))",
+ opacity: 0,
+ },
+ ],
+ },
+ ]}
+ fill={[{ match: () => true, id: "gradient" }]}
+ sliceTooltip={({ slice }: any) => {
+ const point = slice.points[0];
+ const value = point.data.y;
+ const timestamp = point.data.time as DateTime;
+
+ return (
+ <div className="text-sm bg-neutral-900 border border-neutral-700 p-2 rounded-md shadow-md">
+ <div className="flex items-center justify-between gap-3">
+ <div className="text-neutral-200">
+ {formatDateTime(timestamp)}
+ </div>
+ <div className="font-medium">{value.toLocaleString()}</div>
+ </div>
+ </div>
+ );
+ }}
+ />
+ );
+}
+
+const formatDateTime = (dt: DateTime) => {
+ const options: Intl.DateTimeFormatOptions = {
+ month: "short",
+ day: "numeric",
+ hour: "numeric",
+ minute: "numeric",
+ hour12: hour12,
+ };
+
+ return new Intl.DateTimeFormat(userLocale, options).format(dt.toJSDate());
+};
diff --git a/client/src/app/[site]/pages/components/Pagination.tsx b/client/src/app/[site]/pages/components/Pagination.tsx
new file mode 100644
index 000000000..14a182aea
--- /dev/null
+++ b/client/src/app/[site]/pages/components/Pagination.tsx
@@ -0,0 +1,152 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import {
+ ChevronLeft,
+ ChevronRight,
+ ChevronsLeft,
+ ChevronsRight,
+} from "lucide-react";
+
+type PaginationProps = {
+ currentPage: number;
+ totalPages: number;
+ onPageChange: (page: number) => void;
+};
+
+export function Pagination({
+ currentPage,
+ totalPages,
+ onPageChange,
+}: PaginationProps) {
+ const isPrevDisabled = currentPage === 1;
+ const isNextDisabled = currentPage === totalPages || totalPages === 0;
+
+ // Calculate which page numbers to show
+ const getPageNumbers = () => {
+ const pages = [];
+ const maxVisiblePages = 5;
+
+ if (totalPages <= maxVisiblePages) {
+ // Show all pages if there are fewer than maxVisiblePages
+ for (let i = 1; i <= totalPages; i++) {
+ pages.push(i);
+ }
+ } else {
+ // Always show the first page
+ pages.push(1);
+
+ // Logic for showing pages around the current page
+ let startPage = Math.max(2, currentPage - 1);
+ let endPage = Math.min(totalPages - 1, currentPage + 1);
+
+ // Adjust if at the beginning
+ if (currentPage <= 3) {
+ endPage = Math.min(totalPages - 1, 4);
+ }
+
+ // Adjust if at the end
+ if (currentPage >= totalPages - 2) {
+ startPage = Math.max(2, totalPages - 3);
+ }
+
+ // Show ellipsis if needed before startPage
+ if (startPage > 2) {
+ pages.push(-1); // -1 indicates ellipsis
+ }
+
+ // Add middle pages
+ for (let i = startPage; i <= endPage; i++) {
+ pages.push(i);
+ }
+
+ // Show ellipsis if needed after endPage
+ if (endPage < totalPages - 1) {
+ pages.push(-2); // -2 indicates ellipsis
+ }
+
+ // Always show the last page
+ pages.push(totalPages);
+ }
+
+ return pages;
+ };
+
+ const pageNumbers = getPageNumbers();
+
+ return (
+ <div className="flex justify-center items-center gap-1 my-6">
+ {/* First page button */}
+ <Button
+ variant="outline"
+ size="icon"
+ onClick={() => onPageChange(1)}
+ disabled={isPrevDisabled}
+ className="h-8 w-8"
+ >
+ <ChevronsLeft className="h-4 w-4" />
+ </Button>
+
+ {/* Previous page button */}
+ <Button
+ variant="outline"
+ size="icon"
+ onClick={() => onPageChange(currentPage - 1)}
+ disabled={isPrevDisabled}
+ className="h-8 w-8"
+ >
+ <ChevronLeft className="h-4 w-4" />
+ </Button>
+
+ {/* Page numbers */}
+ {pageNumbers.map((pageNum, index) => {
+ if (pageNum < 0) {
+ // Render ellipsis
+ return (
+ <span
+ key={`ellipsis-${index}`}
+ className="px-2 text-muted-foreground"
+ >
+ &hellip;
+ </span>
+ );
+ }
+
+ return (
+ <Button
+ key={pageNum}
+ variant={currentPage === pageNum ? "default" : "outline"}
+ size="sm"
+ onClick={() => onPageChange(pageNum)}
+ className="h-8 w-8"
+ disabled={totalPages === 0}
+ >
+ {pageNum}
+ </Button>
+ );
+ })}
+
+ {/* Next page button */}
+ <Button
+ variant="outline"
+ size="icon"
+ onClick={() => onPageChange(currentPage + 1)}
+ disabled={isNextDisabled}
+ className="h-8 w-8"
+ >
+ <ChevronRight className="h-4 w-4" />
+ </Button>
+
+ {/* Last page button */}
+ <Button
+ variant="outline"
+ size="icon"
+ onClick={() => onPageChange(totalPages)}
+ disabled={isNextDisabled}
+ className="h-8 w-8"
+ >
+ <ChevronsRight className="h-4 w-4" />
+ </Button>
+ </div>
+ );
+}
diff --git a/client/src/app/[site]/pages/page.tsx b/client/src/app/[site]/pages/page.tsx
new file mode 100644
index 000000000..76edd3763
--- /dev/null
+++ b/client/src/app/[site]/pages/page.tsx
@@ -0,0 +1,134 @@
+"use client";
+
+import {
+ PageTitleItem,
+ useGetPageTitlesPaginated,
+} from "@/api/analytics/useGetPageTitles";
+import { useSetPageTitle } from "@/hooks/useSetPageTitle";
+import { useStore } from "@/lib/store";
+import { useEffect, useState } from "react";
+import { SubHeader } from "../components/SubHeader/SubHeader";
+import { PageListItem } from "./components/PageListItem";
+import { PageListSkeleton } from "./components/PageListSkeleton";
+import { Pagination } from "./components/Pagination";
+
+// Number of items per page
+const PAGE_SIZE = 10;
+
+export default function Pages() {
+ const { site } = useStore();
+
+ const [currentPage, setCurrentPage] = useState(1);
+ const [totalPages, setTotalPages] = useState(0);
+
+ useSetPageTitle("Rybbit · Pages");
+
+ if (!site) {
+ return null;
+ }
+
+ // Calculate offset based on current page
+ const offset = (currentPage - 1) * PAGE_SIZE;
+
+ const {
+ data: apiResponse,
+ isLoading: isLoadingPages,
+ isError: isErrorPages,
+ error: pagesError,
+ isPlaceholderData,
+ isFetching,
+ } = useGetPageTitlesPaginated({
+ limit: PAGE_SIZE,
+ offset: offset,
+ });
+
+ const pagesDataArray: PageTitleItem[] | undefined = apiResponse?.data?.data;
+ const totalCount: number | undefined = apiResponse?.data?.totalCount;
+
+ const isLoading = isLoadingPages || isFetching;
+
+ useEffect(() => {
+ if (!isLoadingPages && !isPlaceholderData && !isFetching) {
+ if (totalCount !== undefined) {
+ setTotalPages(Math.ceil(totalCount / PAGE_SIZE));
+ } else if (
+ pagesDataArray &&
+ pagesDataArray.length === 0 &&
+ offset === 0
+ ) {
+ // Fallback if totalCount is somehow undefined but we have an empty array on page 1
+ setTotalPages(0);
+ } else if (pagesDataArray && pagesDataArray.length < PAGE_SIZE) {
+ // Fallback: if less than a full page is returned, assume it's the last
+ setTotalPages(currentPage);
+ }
+ // If totalCount is undefined and we have a full page, we can't be sure of totalPages
+ // In this scenario, the UI might show a next button that leads to an empty page if it was the last one.
+ // This is a limitation if totalCount is not reliably provided.
+ } else if (currentPage === 1 && isLoadingPages && !pagesDataArray) {
+ // Initial load, no data yet
+ setTotalPages(0);
+ }
+ }, [
+ apiResponse,
+ totalCount,
+ pagesDataArray,
+ isLoadingPages,
+ isPlaceholderData,
+ isFetching,
+ currentPage,
+ offset,
+ ]);
+
+ const handlePageChange = (page: number) => {
+ if (page === currentPage || page < 1) return;
+ // With totalCount, we can be more direct.
+ // Allow navigating to any page up to totalPages if totalPages is known and > 0.
+ // If totalPages is 0 (e.g. initial load or no data), only allow navigating to page 1.
+ if (totalPages > 0 && page > totalPages) return;
+ if (totalPages === 0 && page > 1) return;
+
+ setCurrentPage(page);
+ window.scrollTo({ top: 0, behavior: "smooth" });
+ };
+
+ return (
+ <div className="p-2 md:p-4 max-w-[1100px] mx-auto space-y-3">
+ <SubHeader />
+
+ {isLoading ? (
+ <PageListSkeleton count={PAGE_SIZE} />
+ ) : isErrorPages ? (
+ <div className="text-center p-8 text-destructive">
+ <p>Error loading pages data</p>
+ <p className="text-sm">{pagesError?.toString()}</p>
+ </div>
+ ) : pagesDataArray && pagesDataArray.length > 0 ? (
+ <>
+ {pagesDataArray.map((pageItem: PageTitleItem, index: number) => (
+ <PageListItem
+ key={`${pageItem.value}-${index}-${currentPage}`}
+ pageData={{
+ value: pageItem.pathname,
+ title: pageItem.value,
+ count: pageItem.count,
+ percentage: pageItem.percentage,
+ }}
+ />
+ ))}
+ {totalPages > 0 && (
+ <Pagination
+ currentPage={currentPage}
+ totalPages={totalPages}
+ onPageChange={handlePageChange}
+ />
+ )}
+ </>
+ ) : !isLoadingPages && !isFetching ? (
+ <div className="text-center py-12 text-muted-foreground">
+ <p>No pages data found for the selected period.</p>
+ </div>
+ ) : null}
+ </div>
+ );
+}
diff --git a/server/src/api/analytics/getPageTitles.ts b/server/src/api/analytics/getPageTitles.ts
new file mode 100644
index 000000000..074c55d90
--- /dev/null
+++ b/server/src/api/analytics/getPageTitles.ts
@@ -0,0 +1,180 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+import clickhouse from "../../db/clickhouse/clickhouse.js";
+import { getUserHasAccessToSitePublic } from "../../lib/auth-utils.js";
+import {
+ getFilterStatement,
+ getTimeStatement,
+ processResults,
+} from "./utils.js";
+
+interface GetPageTitlesRequest {
+ Params: {
+ site: string;
+ };
+ Querystring: {
+ startDate: string;
+ endDate: string;
+ minutes: number;
+ timeZone: string;
+ filters: string;
+ limit?: number;
+ offset?: number;
+ };
+}
+
+// Represents a single item in the response
+type PageTitleItem = {
+ value: string; // The page_title itself
+ pathname: string; // A representative pathname for this title
+ count: number; // Unique sessions or pageviews for this title
+ percentage: number;
+};
+
+// Structure for paginated response (if/when fully paginated)
+type PageTitlesPaginatedResponse = {
+ data: PageTitleItem[];
+ totalCount: number;
+};
+
+const getPageTitlesQuery = (
+ request: FastifyRequest<GetPageTitlesRequest>,
+ isCountQuery: boolean = false
+) => {
+ const { startDate, endDate, timeZone, filters, limit, offset, minutes } =
+ request.query;
+
+ const filterStatement = getFilterStatement(filters);
+ const timeStatement = getTimeStatement(
+ minutes
+ ? { pastMinutes: Number(minutes) }
+ : {
+ date: { startDate, endDate, timeZone },
+ }
+ );
+
+ let validatedLimit: number | null = null;
+ if (!isCountQuery && limit !== undefined) {
+ const parsedLimit = parseInt(String(limit), 10);
+ if (!isNaN(parsedLimit) && parsedLimit > 0) {
+ validatedLimit = parsedLimit;
+ }
+ }
+ // StandardSection usually shows a small number, e.g., 7 or 10. Let's default to 10 for non-paginated use.
+ const limitStatement =
+ !isCountQuery && validatedLimit
+ ? `LIMIT ${validatedLimit}`
+ : isCountQuery
+ ? ""
+ : "LIMIT 10";
+
+ let validatedOffset: number | null = null;
+ if (!isCountQuery && offset !== undefined) {
+ const parsedOffset = parseInt(String(offset), 10);
+ if (!isNaN(parsedOffset) && parsedOffset >= 0) {
+ validatedOffset = parsedOffset;
+ }
+ }
+ const offsetStatement =
+ !isCountQuery && validatedOffset ? `OFFSET ${validatedOffset}` : "";
+
+ // For page_title, we want to count distinct sessions that viewed this title.
+ // We also need a representative pathname.
+ // Using argMax to get the pathname from the most recent event for that title in a session.
+ const coreLogic = `
+ SELECT
+ page_title as value,
+ argMax(pathname, timestamp) as pathname, // Get pathname of latest event for this title in session
+ COUNT(DISTINCT session_id) as unique_sessions
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND page_title IS NOT NULL
+ AND page_title <> ''
+ AND type = 'pageview' // Ensure these are pageview events
+ ${filterStatement}
+ ${timeStatement}
+ GROUP BY page_title
+ `;
+
+ if (isCountQuery) {
+ return `
+ SELECT COUNT(*) as totalCount FROM (
+ ${coreLogic}
+ );
+ `;
+ }
+
+ // For the data query, we calculate percentages after getting unique_sessions per title
+ return `
+ WITH TitleStats AS (
+ ${coreLogic}
+ )
+ SELECT
+ value,
+ pathname,
+ unique_sessions as count,
+ ROUND(
+ unique_sessions * 100.0 / SUM(unique_sessions) OVER (),
+ 2
+ ) as percentage
+ FROM TitleStats
+ ORDER BY count DESC
+ ${limitStatement}
+ ${offsetStatement};
+ `;
+};
+
+export async function getPageTitles(
+ req: FastifyRequest<GetPageTitlesRequest>,
+ res: FastifyReply
+) {
+ const site = req.params.site;
+ const { offset } = req.query;
+
+ const userHasAccessToSite = await getUserHasAccessToSitePublic(req, site);
+ if (!userHasAccessToSite) {
+ return res.status(403).send({ error: "Forbidden" });
+ }
+
+ const isPaginatedRequest = offset !== undefined; // True if offset is present
+
+ const dataQuery = getPageTitlesQuery(req, false);
+
+ try {
+ const dataResult = await clickhouse.query({
+ query: dataQuery,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ });
+ const items = await processResults<PageTitleItem>(dataResult);
+
+ if (isPaginatedRequest) {
+ const countQuery = getPageTitlesQuery(req, true);
+ const countResult = await clickhouse.query({
+ query: countQuery,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ });
+ const countData = await processResults<{ totalCount: number }>(
+ countResult
+ );
+ const totalCount = countData.length > 0 ? countData[0].totalCount : 0;
+ return res.send({ data: { data: items, totalCount } });
+ } else {
+ // For non-paginated (StandardSection default) use, return the simpler structure
+ return res.send({ data: items });
+ }
+ } catch (error) {
+ console.error(`Error fetching page titles:`, error);
+ console.error("Failed dataQuery:", dataQuery);
+ if (isPaginatedRequest) {
+ const countQuery = getPageTitlesQuery(req, true);
+ console.error("Failed countQuery:", countQuery);
+ }
+ return res.status(500).send({ error: `Failed to fetch page titles` });
+ }
+}
diff --git a/server/src/api/analytics/getSingleCol.ts b/server/src/api/analytics/getSingleCol.ts
index 841e249c6..32f5744a5 100644
--- a/server/src/api/analytics/getSingleCol.ts
+++ b/server/src/api/analytics/getSingleCol.ts
@@ -21,6 +21,7 @@ interface GenericRequest {
filters: string;
parameter: FilterParameter;
limit?: number;
+ offset?: number;
};
}
@@ -37,9 +38,38 @@ type GetSingleColResponse = {
time_on_page_seconds?: number; // avg time on this page when it was an entry/exit
}[];
-const getQuery = (request: FastifyRequest<GenericRequest>) => {
- const { startDate, endDate, timeZone, filters, parameter, limit, minutes } =
- request.query;
+// This type represents a single item in the array returned *within* the data property
+type SingleColItem = {
+ value: string;
+ title?: string;
+ pathname?: string;
+ count: number;
+ percentage: number;
+ pageviews?: number;
+ pageviews_percentage?: number;
+ time_on_page_seconds?: number;
+};
+
+// This is the structure the API will now send
+type GetSingleColPaginatedResponse = {
+ data: SingleColItem[];
+ totalCount: number;
+};
+
+const getQuery = (
+ request: FastifyRequest<GenericRequest>,
+ isCountQuery: boolean = false
+) => {
+ const {
+ startDate,
+ endDate,
+ timeZone,
+ filters,
+ parameter,
+ limit,
+ offset,
+ minutes,
+ } = request.query;
const filterStatement = getFilterStatement(filters);
const timeStatement = getTimeStatement(
@@ -50,29 +80,49 @@ const getQuery = (request: FastifyRequest<GenericRequest>) => {
}
);
- // Validate and sanitize the limit parameter
let validatedLimit: number | null = null;
- if (limit !== undefined) {
+ if (!isCountQuery && limit !== undefined) {
const parsedLimit = parseInt(String(limit), 10);
if (!isNaN(parsedLimit) && parsedLimit > 0) {
validatedLimit = parsedLimit;
}
}
- const limitStatement = validatedLimit
- ? `LIMIT ${validatedLimit}`
- : "LIMIT 100"; // Default limit
+ const limitStatement =
+ !isCountQuery && validatedLimit
+ ? `LIMIT ${validatedLimit}`
+ : isCountQuery
+ ? ""
+ : "LIMIT 100";
- const percentageStatement = `ROUND(
- COUNT(distinct(session_id)) * 100.0 / SUM(COUNT(distinct(session_id))) OVER (),
- 2
- ) as percentage`;
+ let validatedOffset: number | null = null;
+ if (!isCountQuery && offset !== undefined) {
+ const parsedOffset = parseInt(String(offset), 10);
+ if (!isNaN(parsedOffset) && parsedOffset >= 0) {
+ validatedOffset = parsedOffset;
+ }
+ }
+ const offsetStatement =
+ !isCountQuery && validatedOffset ? `OFFSET ${validatedOffset}` : "";
if (parameter === "event_name") {
+ if (isCountQuery) {
+ return `
+ SELECT COUNT(DISTINCT event_name) as totalCount
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND event_name IS NOT NULL
+ AND event_name <> ''
+ ${filterStatement}
+ ${timeStatement}
+ AND type = 'custom_event';
+ `;
+ }
return `
SELECT
event_name as value,
COUNT(*) as count,
- ${percentageStatement}
+ ROUND(COUNT(distinct(session_id)) * 100.0 / SUM(COUNT(distinct(session_id))) OVER (), 2) as percentage
FROM events
WHERE
site_id = {siteId:Int32}
@@ -82,75 +132,113 @@ const getQuery = (request: FastifyRequest<GenericRequest>) => {
${timeStatement}
AND type = 'custom_event'
GROUP BY event_name ORDER BY count desc
- ${limitStatement};
+ ${limitStatement}
+ ${offsetStatement};
`;
}
+ if (parameter === "page_title") {
+ const corePageTitleLogic = `
+ SELECT
+ page_title as value,
+ argMax(pathname, timestamp) as pathname,
+ COUNT(DISTINCT session_id) as unique_sessions
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND page_title IS NOT NULL
+ AND page_title <> ''
+ AND type = 'pageview'
+ ${filterStatement}
+ ${timeStatement}
+ GROUP BY page_title
+ `;
+
+ if (isCountQuery) {
+ return `SELECT COUNT(*) as totalCount FROM (${corePageTitleLogic});`;
+ }
+
+ return `
+ WITH TitleStats AS (
+ ${corePageTitleLogic}
+ )
+ SELECT
+ value, -- This is page_title
+ pathname, -- This is the representative pathname
+ unique_sessions as count,
+ ROUND(
+ unique_sessions * 100.0 / SUM(unique_sessions) OVER (),
+ 2
+ ) as percentage
+ FROM TitleStats
+ ORDER BY count DESC
+ ${limitStatement}
+ ${offsetStatement};
+ `;
+ }
+
if (parameter === "exit_page" || parameter === "entry_page") {
const isEntry = parameter === "entry_page";
const orderDirection = isEntry ? "ASC" : "DESC";
- const rowNumFilter = isEntry ? "row_num = 1" : "row_num = 1"; // Need argMax logic instead if last row needed reliably
+ const rowNumFilter = isEntry ? "row_num = 1" : "row_num = 1";
- // For exit page, row_number() might not be the most robust if events aren't perfectly ordered.
- // argMax(timestamp) per session might be better but makes getting the time_diff harder.
- // Sticking with row_number for now, assuming reasonable ordering.
+ const baseCteQuery = `
+ RelevantEvents AS (
+ SELECT *
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND type = 'pageview'
+ ${filterStatement}
+ ${timeStatement}
+ ),
+ EventTimes AS (
+ SELECT
+ session_id,
+ pathname,
+ timestamp,
+ leadInFrame(timestamp) OVER (PARTITION BY session_id ORDER BY timestamp ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) as next_timestamp,
+ row_number() OVER (PARTITION BY session_id ORDER BY timestamp ${orderDirection}) as row_num
+ FROM RelevantEvents
+ ),
+ PageDurations AS (
+ SELECT
+ session_id,
+ pathname,
+ timestamp,
+ next_timestamp,
+ row_num,
+ if(isNull(next_timestamp), 0, dateDiff('second', timestamp, next_timestamp)) as time_diff_seconds
+ FROM EventTimes
+ ),
+ FilteredDurations AS (
+ SELECT *
+ FROM PageDurations
+ WHERE ${rowNumFilter}
+ ),
+ PathStats AS (
+ SELECT
+ pathname,
+ count(DISTINCT session_id) as unique_sessions,
+ count() as visits,
+ avg(if(time_diff_seconds < 0, 0, if(time_diff_seconds > 1800, 1800, time_diff_seconds))) as avg_time_on_page_seconds
+ FROM FilteredDurations
+ WHERE pathname IS NOT NULL AND pathname <> ''
+ GROUP BY pathname
+ )
+ `;
+
+ if (isCountQuery) {
+ return `
+ WITH ${baseCteQuery}
+ SELECT COUNT(DISTINCT pathname) as totalCount FROM PathStats;
+ `;
+ }
return `
- WITH RelevantEvents AS (
- -- Select all pageview events matching filters and time range
- SELECT *
- FROM events
- WHERE
- site_id = {siteId:Int32}
- AND type = 'pageview'
- ${filterStatement}
- ${timeStatement}
- ),
- EventTimes AS (
- -- Calculate next timestamp within each session for duration calculation
- SELECT
- session_id,
- pathname,
- timestamp,
- leadInFrame(timestamp) OVER (PARTITION BY session_id ORDER BY timestamp ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) as next_timestamp,
- -- Assign row number to identify first/last event per session
- row_number() OVER (PARTITION BY session_id ORDER BY timestamp ${orderDirection}) as row_num
- FROM RelevantEvents
- ),
- PageDurations AS (
- -- Calculate duration for each pageview and keep row number
- SELECT
- session_id,
- pathname,
- timestamp,
- next_timestamp,
- row_num,
- if(isNull(next_timestamp), 0, dateDiff('second', timestamp, next_timestamp)) as time_diff_seconds
- FROM EventTimes
- ),
- FilteredDurations AS (
- -- Filter durations to only include the entry or exit event
- SELECT *
- FROM PageDurations
- WHERE ${rowNumFilter}
- ),
- PathStats AS (
- -- Aggregate stats for the filtered entry/exit pages
- SELECT
- pathname,
- -- Count distinct sessions where this path was entry/exit
- count(DISTINCT session_id) as unique_sessions,
- -- Count pageviews for this path when it was entry/exit (should be same as unique_sessions here)
- count() as visits,
- -- Calculate average time spent on this page when it was the entry/exit page
- avg(if(time_diff_seconds < 0, 0, if(time_diff_seconds > 1800, 1800, time_diff_seconds))) as avg_time_on_page_seconds
- FROM FilteredDurations
- WHERE pathname IS NOT NULL AND pathname <> ''
- GROUP BY pathname
- )
- -- Final selection with percentages
+ WITH ${baseCteQuery}
SELECT
- pathname as value,
+ pathname as value,
unique_sessions as count,
round((unique_sessions / sum(unique_sessions) OVER ()) * 100, 2) as percentage,
visits as pageviews,
@@ -158,48 +246,54 @@ const getQuery = (request: FastifyRequest<GenericRequest>) => {
avg_time_on_page_seconds as time_on_page_seconds
FROM PathStats
ORDER BY unique_sessions DESC
- ${limitStatement};`;
+ ${limitStatement}
+ ${offsetStatement};`;
}
if (parameter === "pathname") {
+ const baseCteQuery = `
+ EventTimes AS (
+ SELECT
+ session_id,
+ pathname,
+ timestamp,
+ leadInFrame(timestamp) OVER (PARTITION BY session_id ORDER BY timestamp ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) as next_timestamp
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND type = 'pageview'
+ ${filterStatement}
+ ${timeStatement}
+ ),
+ PageDurations AS (
+ SELECT
+ session_id,
+ pathname,
+ timestamp,
+ next_timestamp,
+ if(isNull(next_timestamp), 0, dateDiff('second', timestamp, next_timestamp)) as time_diff_seconds
+ FROM EventTimes
+ ),
+ PathStats AS (
+ SELECT
+ pathname,
+ count() as visits,
+ count(DISTINCT session_id) as unique_sessions,
+ avg(if(time_diff_seconds < 0, 0, if(time_diff_seconds > 1800, 1800, time_diff_seconds))) as avg_time_on_page_seconds
+ FROM PageDurations
+ GROUP BY pathname
+ )
+ `;
+ if (isCountQuery) {
+ return `
+ WITH ${baseCteQuery}
+ SELECT COUNT(DISTINCT pathname) as totalCount FROM PathStats;
+ `;
+ }
return `
- WITH EventTimes AS (
- SELECT
- session_id,
- pathname,
- page_title,
- timestamp,
- leadInFrame(timestamp) OVER (PARTITION BY session_id ORDER BY timestamp ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) as next_timestamp
- FROM events
- WHERE
- site_id = {siteId:Int32}
- AND type = 'pageview'
- ${filterStatement}
- ${timeStatement}
- ),
- PageDurations AS (
- SELECT
- session_id,
- pathname,
- page_title,
- timestamp,
- next_timestamp,
- if(isNull(next_timestamp), 0, dateDiff('second', timestamp, next_timestamp)) as time_diff_seconds
- FROM EventTimes
- ),
- PathStats AS (
- SELECT
- pathname,
- page_title,
- count() as visits,
- count(DISTINCT session_id) as unique_sessions,
- avg(if(time_diff_seconds < 0, 0, if(time_diff_seconds > 1800, 1800, time_diff_seconds))) as avg_time_on_page_seconds
- FROM PageDurations
- GROUP BY pathname, page_title
- )
+ WITH ${baseCteQuery}
SELECT
pathname as value,
- page_title as title,
unique_sessions as count,
round((unique_sessions / sum(unique_sessions) OVER ()) * 100, 2) as percentage,
visits as pageviews,
@@ -207,24 +301,39 @@ const getQuery = (request: FastifyRequest<GenericRequest>) => {
avg_time_on_page_seconds as time_on_page_seconds
FROM PathStats
ORDER BY unique_sessions DESC
- ${limitStatement};
+ ${limitStatement}
+ ${offsetStatement};
+ `;
+ }
+
+ // Default case for other parameters
+ const sqlParam = getSqlParam(parameter);
+ if (isCountQuery) {
+ return `
+ SELECT COUNT(DISTINCT ${sqlParam}) as totalCount
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND ${sqlParam} IS NOT NULL
+ AND ${sqlParam} <> ''
+ ${filterStatement}
+ ${timeStatement};
`;
}
return `
WITH PageStats AS (
SELECT
- ${getSqlParam(parameter)} as value,
+ ${sqlParam} as value,
COUNT(distinct(session_id)) as unique_sessions,
COUNT() as pageviews
FROM events
WHERE
site_id = {siteId:Int32}
- AND ${getSqlParam(parameter)} IS NOT NULL
- AND ${getSqlParam(parameter)} <> ''
+ AND ${sqlParam} IS NOT NULL
+ AND ${sqlParam} <> ''
${filterStatement}
${timeStatement}
- // AND type = 'pageview'
GROUP BY value
)
SELECT
@@ -235,7 +344,8 @@ const getQuery = (request: FastifyRequest<GenericRequest>) => {
round((pageviews / sum(pageviews) OVER ()) * 100, 2) as pageviews_percentage
FROM PageStats
ORDER BY count desc
- ${limitStatement};
+ ${limitStatement}
+ ${offsetStatement};
`;
};
@@ -243,7 +353,7 @@ export async function getSingleCol(
req: FastifyRequest<GenericRequest>,
res: FastifyReply
) {
- const { parameter } = req.query;
+ const { parameter, offset, limit } = req.query;
const site = req.params.site;
const userHasAccessToSite = await getUserHasAccessToSitePublic(req, site);
@@ -251,23 +361,45 @@ export async function getSingleCol(
return res.status(403).send({ error: "Forbidden" });
}
- const query = getQuery(req);
+ const isPaginatedRequest = offset !== undefined;
+
+ const dataQuery = getQuery(req, false);
try {
- const result = await clickhouse.query({
- query,
+ const dataResult = await clickhouse.query({
+ query: dataQuery,
format: "JSONEachRow",
query_params: {
siteId: Number(site),
},
});
+ const items = await processResults<SingleColItem>(dataResult);
- const data = await processResults<GetSingleColResponse[number]>(result);
- return res.send({ data });
+ if (isPaginatedRequest) {
+ const countQuery = getQuery(req, true);
+ const countResult = await clickhouse.query({
+ query: countQuery,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ });
+ const countData = await processResults<{ totalCount: number }>(
+ countResult
+ );
+ const totalCount = countData.length > 0 ? countData[0].totalCount : 0;
+
+ return res.send({ data: { data: items, totalCount } });
+ } else {
+ return res.send({ data: items });
+ }
} catch (error) {
console.error(`Error fetching ${parameter}:`, error);
- // Add query to error log for easier debugging
- console.error("Failed query:", query);
+ console.error("Failed dataQuery:", dataQuery);
+ if (isPaginatedRequest) {
+ const countQuery = getQuery(req, true);
+ console.error("Failed countQuery:", countQuery);
+ }
return res.status(500).send({ error: `Failed to fetch ${parameter}` });
}
}
diff --git a/server/src/index.ts b/server/src/index.ts
index 3d8cc5d89..59e588fdf 100644
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@ -58,6 +58,7 @@ import { handleWebhook } from "./api/stripe/webhook.js";
import { IS_CLOUD } from "./lib/const.js";
import { addUserToOrganization } from "./api/user/addUserToOrganization.js";
import { getConfig } from "./api/getConfig.js";
+import { getPageTitles } from "./api/analytics/getPageTitles.js";
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
@@ -133,6 +134,7 @@ const ANALYTICS_ROUTES = [
"/overview/",
"/overview-bucketed/",
"/single-col/",
+ "/page-titles/",
"/retention/",
"/site-has-data/",
"/site-is-public/",
@@ -200,6 +202,7 @@ server.get("/live-user-count/:site", getLiveUsercount);
server.get("/overview/:site", getOverview);
server.get("/overview-bucketed/:site", getOverviewBucketed);
server.get("/single-col/:site", getSingleCol);
+server.get("/page-titles/:site", getPageTitles);
server.get("/retention/:site", getRetention);
server.get("/site-has-data/:site", getSiteHasData);
server.get("/site-is-public/:site", getSiteIsPublic);