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.

2.8 KB
Raw Blame
import { formatUTCDateTimeClickhouse } from "@/lib/analytics/utils/format-utc-datetime-clickhouse";
import { getStartEndDates } from "@/lib/analytics/utils/get-start-end-dates";
import { sanitizeTimezone } from "@/lib/analytics/utils/sanitize-timezone";
import { prisma } from "@/lib/prisma";
import { usageQuerySchema, usageResponse } from "@/lib/zod/schemas/usage";
import * as z from "zod/v4";
import { tb } from "./client";

const usagePipe = tb.buildPipe({
  pipe: "v4_usage",
  parameters: usageQuerySchema.extend({
    workspaceId: z.string(),
    granularity: z.enum(["minute", "hour", "day", "month"]).optional(),
  }),
  data: usageResponse,
});

const sum = (arr: number[]) => arr.reduce((acc, curr) => acc + curr, 0);

export type GetWorkspaceUsageParams = {
  workspaceId: string;
  resource: z.infer<typeof usageQuerySchema>["resource"];
  folderId?: string;
  domain?: string;
  groupBy?: "folder_id" | "domain";
  interval?: z.infer<typeof usageQuerySchema>["interval"];
  start?: string | Date;
  end?: string | Date;
  timezone?: string;
};

export async function getWorkspaceUsage({
  workspaceId,
  resource,
  folderId,
  domain,
  groupBy,
  interval,
  start,
  end,
  timezone = "UTC",
}: GetWorkspaceUsageParams) {
  timezone = sanitizeTimezone(timezone);

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

  const response = await usagePipe({
    resource,
    workspaceId,
    start: formatUTCDateTimeClickhouse(startDate),
    end: formatUTCDateTimeClickhouse(endDate),
    timezone,
    granularity,
    ...(folderId && { folderId }),
    ...(domain && { domain }),
    ...(groupBy && { groupBy }),
  });

  let data = response.data;

  if (groupBy) {
    const dates = [...new Set(response.data.map((d) => d.date))];
    const groupIds = [...new Set(response.data.map((d) => d[groupBy] ?? ""))];

    const where = {
      projectId: workspaceId,
      id: {
        in: groupIds,
      },
    };

    const groupMeta = await (groupBy === "folder_id"
      ? prisma.folder.findMany({
          select: {
            id: true,
            name: true,
          },
          where,
        })
      : prisma.domain.findMany({
          select: {
            id: true,
            slug: true,
          },
          where,
        }));

    data = dates.map((date) => {
      const groups = groupIds.map((groupId) => ({
        id: groupId,
        name:
          groupMeta.find((g) => g.id === groupId)?.[
            groupBy === "folder_id" ? "name" : "slug"
          ] ?? groupId,
        usage: sum(
          response.data
            .filter((d) => d.date === date && d[groupBy] === groupId)
            .map((d) => d.value),
        ),
      }));

      return {
        date,
        value: sum(groups.map((g) => g.usage)),
        groups,
      };
    });
  }

  return data;
}