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.

6.0 KB
Raw Blame
import { getFirstFilterValue } from "@/lib/analytics/filter-helpers";
import { getAnalytics } from "@/lib/analytics/get-analytics";
import { DubApiError, handleAndReturnErrorResponse } from "@/lib/api/errors";
import { assertValidDateRangeForPlan } from "@/lib/api/utils/assert-valid-date-range-for-plan";
import { exceededLimitError } from "@/lib/exceeded-limit-error";
import { prisma } from "@/lib/prisma";
import { redis } from "@/lib/upstash";
import { parseAnalyticsQuery } from "@/lib/zod/schemas/analytics";
import { DUB_DEMO_LINKS, DUB_WORKSPACE_ID, getSearchParams } from "@dub/utils";
import { waitUntil } from "@vercel/functions";
import { cookies } from "next/headers";
import { NextResponse } from "next/server";

export const dynamic = "force-dynamic";

// GET /api/analytics/dashboard – get analytics for the dashboard
export const GET = async (req: Request) => {
  try {
    const searchParams = getSearchParams(req.url);
    const parsedParams = parseAnalyticsQuery(searchParams);

    const {
      domain: domainFilter,
      key,
      folderId: folderIdFilter,
      interval,
      start,
      end,
    } = parsedParams;

    // Extract string values for specific link/folder lookup
    const domain = getFirstFilterValue(domainFilter);
    const folderId = getFirstFilterValue(folderIdFilter);

    if ((!domain || !key) && !folderId) {
      throw new DubApiError({
        code: "bad_request",
        message: "Missing domain/key or folderId query parameters",
      });
    }

    let demoLink, link, folder, workspace;

    if (folderId) {
      // Folder
      folder = await prisma.folder.findUnique({
        where: {
          id: folderId,
        },
        select: {
          id: true,
          dashboard: {
            select: {
              id: true,
              password: true,
            },
          },
          projectId: true,
          project: {
            select: {
              id: true,
              plan: true,
              usage: true,
              usageLimit: true,
              createdAt: true,
            },
          },
          ...(domain && key
            ? {
                links: {
                  select: { id: true },
                  where: {
                    domain,
                    key,
                  },
                },
              }
            : {}),
        },
      });

      if (!folder?.dashboard) {
        throw new DubApiError({
          code: "forbidden",
          message: "This folder does not have a public analytics dashboard",
        });
      }

      await assertDashboardPassword(folder.dashboard);

      workspace = folder.project;

      if ("links" in folder && folder.links?.length) link = folder.links[0];
    } else {
      // Link
      demoLink = DUB_DEMO_LINKS.find(
        (l) => l.domain === domain && l.key === key,
      );

      // if it's a demo link
      if (demoLink) {
        link = {
          id: demoLink.id,
          projectId: DUB_WORKSPACE_ID,
        };
      } else {
        link = await prisma.link.findUnique({
          where: {
            domain_key: { domain: domain!, key: key! },
          },
          select: {
            id: true,
            dashboard: {
              select: {
                id: true,
                password: true,
              },
            },
            projectId: true,
            project: {
              select: {
                id: true,
                plan: true,
                usage: true,
                usageLimit: true,
                createdAt: true,
              },
            },
          },
        });

        if (!link?.dashboard) {
          throw new DubApiError({
            code: "forbidden",
            message: "This link does not have a public analytics dashboard",
          });
        }

        await assertDashboardPassword(link.dashboard);

        workspace = link.project;
      }
    }

    assertValidDateRangeForPlan({
      plan: workspace?.plan || "free",
      dataAvailableFrom: workspace?.createdAt,
      interval,
      start,
      end,
    });

    if (workspace && workspace.usage > workspace.usageLimit) {
      throw new DubApiError({
        code: "forbidden",
        message: exceededLimitError({
          plan: workspace.plan,
          planPeriod: workspace.planPeriod,
          limit: workspace.usageLimit,
          type: "clicks",
        }),
      });
    }

    // Create cache key based on all parameters that affect the result
    const cacheKey = `analyticsDashboardCache:${JSON.stringify(parsedParams)}`;

    // Check if results exist in cache
    const cached = await redis.get(cacheKey);
    if (cached) {
      console.log(
        `[Analytics Dashboard] Cache hit: ${JSON.stringify(parsedParams, null, 2)}`,
      );
      return NextResponse.json(cached);
    }

    console.log(
      `[Analytics Dashboard] Cache miss: ${JSON.stringify(parsedParams, null, 2)}`,
    );

    // When domain+key resolves a specific link, exclude domain from filters
    const { domain: _domain, key: _key, ...filterParams } = parsedParams;

    const response = await getAnalytics({
      ...(link ? filterParams : parsedParams),
      // workspaceId can be undefined (for public links that haven't been claimed/synced to a workspace)
      ...(workspace && { workspaceId: workspace.id }),
      ...(folder && { folderId: folder.id }),
      ...(link && { linkId: link.id }),
    });

    // Cache the response for 1 minute
    console.log(
      `[Analytics Dashboard] Caching response for ${JSON.stringify(parsedParams, null, 2)}`,
    );
    waitUntil(redis.set(cacheKey, response, { ex: 60 }));

    return NextResponse.json(response);
  } catch (error) {
    return handleAndReturnErrorResponse(error);
  }
};

async function assertDashboardPassword(dashboard: {
  id: string;
  password: string | null;
}) {
  if (!dashboard.password) {
    return;
  }

  const cookiePassword = (await cookies()).get(
    `dub_password_${dashboard.id}`,
  )?.value;

  if (cookiePassword !== dashboard.password) {
    throw new DubApiError({
      code: "unauthorized",
      message: "This dashboard is password protected",
    });
  }
}