The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.
TypeScript clickhousemysqlnextjsopen-sourceplanetscaleprismatailwindcsstinybirdtypescriptupstashvercel
import { FOLDER_WORKSPACE_ACCESS } from "@/lib/folder/constants";
import { prisma } from "@/lib/prisma";
import { tb } from "@/lib/tinybird";
import { FolderAccessLevel } from "@/lib/types";
import { linkConstructor, punyEncode } from "@dub/utils";
import * as z from "zod/v4";
import { decodeKeyIfCaseSensitive } from "../api/links/case-sensitivity";
import { conn } from "../planetscale";
import { analyticsFilterTB } from "../zod/schemas/analytics";
import { analyticsResponse } from "../zod/schemas/analytics-response";
import {
DIMENSIONAL_ANALYTICS_FILTERS,
SINGULAR_ANALYTICS_ENDPOINTS,
} from "./constants";
import {
buildAdvancedFilters,
ensureParsedFilter,
extractWorkspaceLinkFilters,
prepareFiltersForPipe,
} from "./filter-helpers";
import { metadataQueryParser } from "./metadata-query-parser";
import { AnalyticsFilters } from "./types";
import { formatUTCDateTimeClickhouse } from "./utils/format-utc-datetime-clickhouse";
import { getStartEndDates } from "./utils/get-start-end-dates";
import { withTinybirdTimeout } from "./utils/with-tinybird-timeout";
// Fetch data for /api/analytics
export const getAnalytics = async (params: AnalyticsFilters) => {
let {
event,
groupBy,
workspaceId,
linkId,
interval,
start,
end,
qr,
trigger,
region,
country,
timezone = "UTC",
isDeprecatedClicksEndpoint = false,
dataAvailableFrom,
query,
} = params;
const normalizedLinkId = ensureParsedFilter(linkId);
// get all-time clicks count if:
// 1. linkId is defined
// 2. type is count
// 3. interval is all
// 4. no custom start or end date is provided
// 5. no other dimensional filters are applied
if (
normalizedLinkId &&
groupBy === "count" &&
interval === "all" &&
!start &&
!end &&
DIMENSIONAL_ANALYTICS_FILTERS.every(
(filter) => !params[filter as keyof AnalyticsFilters],
)
) {
const linkIdPlaceholders = normalizedLinkId.values.map(() => "?").join(",");
const aggregateColumns =
event === "composite"
? `SUM(clicks) as clicks, SUM(leads) as leads, SUM(sales) as sales, SUM(saleAmount) as saleAmount`
: event === "sales"
? `SUM(sales) as sales, SUM(saleAmount) as saleAmount`
: `SUM(${event}) as ${event}`;
const response = await conn.execute(
`SELECT ${aggregateColumns} FROM Link WHERE id IN (${linkIdPlaceholders}) AND projectId = ?`,
[...normalizedLinkId.values, workspaceId],
);
return analyticsResponse["count"].parse(response.rows[0]);
}
if (groupBy === "trigger") groupBy = "triggers";
const { startDate, endDate, granularity } = getStartEndDates({
interval,
start,
end,
dataAvailableFrom,
timezone,
});
const { triggerForPipe, countryForPipe, regionForPipe } =
prepareFiltersForPipe({
qr,
trigger,
region,
country,
});
// Create a Tinybird pipe
const pipe = tb.buildPipe({
pipe: ["count", "timeseries"].includes(groupBy!)
? `v4_${groupBy}`
: ["top_folders", "top_link_tags", "top_domains"].includes(groupBy!)
? "v4_group_by_link_metadata"
: "v4_group_by",
parameters: analyticsFilterTB,
data: z.object({
groupByField: z.string(),
clicks: z.number().default(0),
leads: z.number().default(0),
sales: z.number().default(0),
saleAmount: z.number().default(0),
// only for cities and regions groupBy
country: z.string().optional(),
region: z.string().optional(),
}),
});
const metadataFilters = metadataQueryParser(query) || [];
const advancedFilters = buildAdvancedFilters({
...params,
country: countryForPipe,
trigger: triggerForPipe,
});
const allFilters = [...metadataFilters, ...advancedFilters];
const folderIdFilter = ensureParsedFilter(params.folderId);
let {
domain: domainParam,
domainOperator,
linkId: linkIdParam,
linkIdOperator,
folderId: folderIdParam,
folderIdOperator,
tagId: tagIdParam,
tagIdOperator,
tenantId: tenantIdParam,
tenantIdOperator,
} = extractWorkspaceLinkFilters({
...params,
linkId: normalizedLinkId,
folderId: folderIdFilter,
});
const tinybirdParams: any = {
workspaceId,
customerId: params.customerId,
tenantId: tenantIdParam,
tenantIdOperator,
linkId: linkIdParam,
linkIdOperator,
domain: domainParam,
domainOperator,
folderId: folderIdParam,
folderIdOperator,
tagId: tagIdParam,
tagIdOperator,
groupBy,
eventType: event,
start: formatUTCDateTimeClickhouse(startDate),
end: formatUTCDateTimeClickhouse(endDate),
granularity,
timezone,
region: typeof regionForPipe === "string" ? regionForPipe : undefined,
root: params.root,
saleType: params.saleType,
filters: allFilters.length > 0 ? JSON.stringify(allFilters) : undefined,
};
const response = await withTinybirdTimeout(pipe(tinybirdParams));
if (groupBy === "count") {
const { groupByField, ...rest } = response.data[0];
// Return the count value for deprecated count endpoints
if (isDeprecatedClicksEndpoint) {
return rest[event!];
// Return the object for regular count endpoints
} else {
return rest;
}
} else if (groupBy === "top_links") {
const links = await prisma.link.findMany({
where: {
id: {
in: response.data.map((item) => item.groupByField),
},
},
select: {
id: true,
domain: true,
key: true,
url: true,
title: true,
comments: true,
folderId: true,
createdAt: true,
},
});
return response.data
.map((item) => {
const link = links.find((l) => l.id === item.groupByField);
if (!link) {
return null;
}
link.key = decodeKeyIfCaseSensitive({
domain: link.domain,
key: link.key,
});
return analyticsResponse[groupBy].parse({
...link,
link: link.id,
key: punyEncode(link.key),
shortLink: linkConstructor({
domain: link.domain,
key: punyEncode(link.key),
}),
createdAt: link.createdAt.toISOString(),
...item,
});
})
.filter((d) => d !== null);
} else if (groupBy === "top_link_tags") {
const tags = await prisma.tag.findMany({
where: {
id: {
in: response.data.map((item) => item.groupByField),
},
},
});
return response.data
.map((item) => {
const tag = tags.find((t) => t.id === item.groupByField);
if (!tag) return null;
return analyticsResponse[groupBy].parse({
...item,
tagId: item.groupByField,
tag,
});
})
.filter((d) => d !== null);
} else if (groupBy === "top_folders") {
const folders = await prisma.folder.findMany({
where: {
id: {
in: response.data.map((item) => item.groupByField),
},
},
select: {
id: true,
name: true,
accessLevel: true,
},
});
return response.data
.map((item) => {
const folder = folders.find((f) => f.id === item.groupByField);
if (!folder) return null;
return analyticsResponse.top_folders
.extend({
folder: analyticsResponse.top_folders.shape.folder.extend({
accessLevel: z
.enum(
Object.keys(FOLDER_WORKSPACE_ACCESS) as [
FolderAccessLevel,
...FolderAccessLevel[],
],
)
.nullish(),
}),
})
.parse({
...item,
folderId: item.groupByField,
folder,
});
})
.filter((d) => d !== null);
}
// Return array for other endpoints
const schema = analyticsResponse[groupBy!];
return response.data.map((item) =>
schema.parse({
...item,
[SINGULAR_ANALYTICS_ENDPOINTS[groupBy!]]: item.groupByField,
}),
);
};