Skip to content

armgit / dub

Public Imported from GitHub
0

The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.

7.9 KB
Raw Blame
import { prisma } from "@/lib/prisma";
import { tb } from "@/lib/tinybird";
import { Link } from "@prisma/client";
import * as z from "zod/v4";
import { decodeLinkIfCaseSensitive } from "../api/links/case-sensitivity";
import { transformLink } from "../api/links/utils/transform-link";
import { generateRandomName } from "../names";
import { eventsFilterTB } from "../zod/schemas/analytics";
import {
  clickEventResponseSchema,
  clickEventSchema,
  clickEventSchemaTBEndpoint,
} from "../zod/schemas/clicks";
import { CustomerSchema } from "../zod/schemas/customers";
import {
  leadEventResponseSchema,
  leadEventSchemaTBEndpoint,
} from "../zod/schemas/leads";
import {
  saleEventResponseSchema,
  saleEventSchemaTBEndpoint,
} from "../zod/schemas/sales";
import {
  buildAdvancedFilters,
  ensureParsedFilter,
  extractWorkspaceLinkFilters,
  prepareFiltersForPipe,
} from "./filter-helpers";
import { metadataQueryParser } from "./metadata-query-parser";
import { EventsFilters } 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/events
export const getEvents = async (params: EventsFilters) => {
  let {
    event: eventType,
    workspaceId,
    interval,
    start,
    end,
    timezone = "UTC",
    qr,
    trigger,
    region,
    country,
    order,
    sortOrder,
    dataAvailableFrom,
    query,
    includeMetadata = true,
    page,
    limit,
  } = params;

  const { startDate, endDate } = getStartEndDates({
    interval,
    start,
    end,
    dataAvailableFrom,
    timezone,
  });

  const { triggerForPipe, countryForPipe, regionForPipe } =
    prepareFiltersForPipe({
      qr,
      trigger,
      region,
      country,
    });

  // support legacy order param
  if (order && order !== "desc") {
    sortOrder = order;
  }

  const pipe = tb.buildPipe({
    pipe: "v4_events",
    parameters: eventsFilterTB,
    data:
      {
        clicks: clickEventSchemaTBEndpoint,
        leads: leadEventSchemaTBEndpoint,
        sales: saleEventSchemaTBEndpoint,
      }[eventType] ?? clickEventSchemaTBEndpoint,
  });

  const metadataFilters = metadataQueryParser(query) || [];

  // Build advanced filters for event-level dimensions
  const advancedFilters = buildAdvancedFilters({
    ...params,
    country: countryForPipe,
    trigger: triggerForPipe,
  });

  const allFilters = [...metadataFilters, ...advancedFilters];

  const linkIdFilter = ensureParsedFilter(params.linkId);
  const folderIdFilter = ensureParsedFilter(params.folderId);

  const {
    linkId: linkIdParam,
    linkIdOperator,
    domain: domainParam,
    domainOperator,
    tagId: tagIdParam,
    tagIdOperator,
    folderId: folderIdParam,
    folderIdOperator,
    tenantId: tenantIdParam,
    tenantIdOperator,
  } = extractWorkspaceLinkFilters({
    ...params,
    linkId: linkIdFilter,
    folderId: folderIdFilter,
  });

  const tinybirdParams: any = {
    eventType,
    workspaceId,
    customerId: params.customerId,
    linkId: linkIdParam,
    linkIdOperator,
    folderId: folderIdParam,
    folderIdOperator,
    tenantId: tenantIdParam,
    tenantIdOperator,
    ...(typeof triggerForPipe !== "object" && triggerForPipe
      ? { trigger: triggerForPipe }
      : {}),
    ...(typeof countryForPipe !== "object" && countryForPipe
      ? { country: countryForPipe }
      : {}),
    ...(typeof regionForPipe === "string" ? { region: regionForPipe } : {}),
    // Workspace links filters with operators
    ...(domainParam ? { domain: domainParam, domainOperator } : {}),
    ...(tagIdParam ? { tagId: tagIdParam, tagIdOperator } : {}),
    ...(folderIdParam ? { folderId: folderIdParam, folderIdOperator } : {}),
    ...(params.root !== undefined ? { root: params.root } : {}),
    ...(params.saleType ? { saleType: params.saleType } : {}),
    order: sortOrder,
    offset: (page - 1) * limit,
    limit,
    sortBy: params.sortBy,
    start: formatUTCDateTimeClickhouse(startDate),
    end: formatUTCDateTimeClickhouse(endDate),
    filters: allFilters.length > 0 ? JSON.stringify(allFilters) : undefined,
  };

  const response = await withTinybirdTimeout(pipe(tinybirdParams));

  const [linksMap, customersMap] = await Promise.all([
    getLinksMap(response.data.map((d) => d.link_id)),
    getCustomersMap(
      response.data
        .map((d) => {
          if (d.event === "lead" || d.event === "sale") {
            return d.customer_id;
          }
          return null;
        })
        .filter(Boolean) as string[],
    ),
  ]);

  const events = response.data
    .map((evt) => {
      let link = linksMap[evt.link_id];
      if (!link) {
        return null;
      }

      link = decodeLinkIfCaseSensitive(link);

      const transformedLink = transformLink(link, { skipDecodeKey: true });
      if (
        transformedLink.testVariants &&
        !Array.isArray(transformedLink.testVariants)
      ) {
        transformedLink.testVariants = null;
      }

      const eventData = {
        ...evt,
        // use link domain & key from mysql instead of tinybird
        domain: link.domain,
        key: link.key,
        // timestamp is always in UTC
        timestamp: new Date(evt.timestamp + "Z"),
        click: clickEventSchema.parse({
          ...evt,
          id: evt.click_id,
          // normalize processed values
          region: evt.region_processed ?? "",
          refererUrl: evt.referer_url_processed ?? "",
        }),
        // transformLink -> add shortLink, qrCode, workspaceId, etc.
        link: transformedLink,
        ...(evt.event === "lead" || evt.event === "sale"
          ? {
              eventId: evt.event_id,
              eventName: evt.event_name,
              metadata:
                !includeMetadata || !evt.metadata
                  ? undefined
                  : JSON.parse(evt.metadata),
              customer: customersMap[evt.customer_id] ?? {
                id: evt.customer_id,
                name: "Deleted Customer",
                email: "[email protected]",
                externalId: evt.customer_id,
                createdAt: new Date("1970-01-01"),
              },
              ...(evt.event === "sale"
                ? {
                    sale: {
                      amount: evt.saleAmount,
                      invoiceId: evt.invoice_id,
                      paymentProcessor: evt.payment_processor,
                      currency: evt.currency,
                    },
                  }
                : {}),
            }
          : {}),
      };

      if (evt.event === "click") {
        return clickEventResponseSchema.parse(eventData);
      } else if (evt.event === "lead") {
        return leadEventResponseSchema.parse(eventData);
      } else if (evt.event === "sale") {
        return saleEventResponseSchema.parse(eventData);
      }

      return eventData;
    })
    .filter((d) => d !== null);

  return events;
};

const getLinksMap = async (linkIds: string[]) => {
  const links = await prisma.link.findMany({
    where: {
      id: {
        in: linkIds,
      },
    },
  });

  return links.reduce(
    (acc, link) => {
      acc[link.id] = link;
      return acc;
    },
    {} as Record<string, Link>,
  );
};

const getCustomersMap = async (customerIds: string[]) => {
  if (customerIds.length === 0) {
    return {};
  }

  const customers = await prisma.customer.findMany({
    where: {
      id: {
        in: customerIds,
      },
    },
  });

  return customers.reduce(
    (acc, customer) => {
      acc[customer.id] = CustomerSchema.parse({
        id: customer.id,
        externalId: customer.externalId || "",
        name: customer.name || customer.email || generateRandomName(),
        email: customer.email || "",
        avatar: customer.avatar,
        country: customer.country || "",
        createdAt: customer.createdAt,
      });
      return acc;
    },
    {} as Record<string, z.infer<typeof CustomerSchema>>,
  );
};