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.8 KB
Raw Blame
"use client";

import {
  ANALYTICS_SALE_UNIT,
  ANALYTICS_VIEWS,
  DUB_LINKS_ANALYTICS_INTERVAL,
} from "@/lib/analytics/constants";
import {
  AnalyticsResponseOptions,
  AnalyticsSaleUnit,
  AnalyticsView,
  EventType,
} from "@/lib/analytics/types";
import { editQueryString } from "@/lib/analytics/utils";
import { getPlanCapabilities } from "@/lib/plan-capabilities";
import useWorkspace from "@/lib/swr/use-workspace";
import { PlanProps } from "@/lib/types";
import { useLocalStorage } from "@dub/ui";
import { fetcher } from "@dub/utils";
import { useParams, useSearchParams } from "next/navigation";
import {
  createContext,
  PropsWithChildren,
  useEffect,
  useMemo,
  useState,
} from "react";
import { toast } from "sonner";
import useSWR from "swr";
import { defaultConfig } from "swr/_internal";
import { UpgradeRequiredToast } from "../shared/upgrade-required-toast";
import { useAnalyticsQuery } from "./use-analytics-query";

export type AnalyticsDashboardProps = {
  showConversions?: boolean;
  workspacePlan?: PlanProps;
} & (
  | {
      domain: string;
      key: string;
      url: string;
      folderId?: never;
      folderName?: never;
    }
  | {
      folderId: string;
      folderName: string;
      domain?: never;
      key?: never;
      url?: never;
    }
);

export const AnalyticsContext = createContext<{
  basePath: string;
  baseApiPath: string;
  eventsApiPath?: string;
  selectedTab: EventType;
  saleUnit: AnalyticsSaleUnit;
  view: AnalyticsView;
  domain?: string;
  key?: string;
  url?: string;
  folderId?: string;
  queryString: string;
  start?: Date;
  end?: Date;
  interval?: string;
  tagId?: string;
  totalEvents?: {
    [key in AnalyticsResponseOptions]: number;
  };
  totalEventsLoading?: boolean;
  showConversions?: boolean;
  fetchCompositeStats?: boolean;
  requiresUpgrade?: boolean;
  dashboardProps?: AnalyticsDashboardProps;
}>({
  basePath: "",
  baseApiPath: "",
  eventsApiPath: "",
  selectedTab: "clicks",
  saleUnit: "saleAmount",
  view: "timeseries",
  domain: "",
  queryString: "",
  start: new Date(),
  end: new Date(),
  showConversions: false,
  fetchCompositeStats: false,
  requiresUpgrade: false,
  dashboardProps: undefined,
});

export default function AnalyticsProvider({
  dashboardProps,
  children,
}: PropsWithChildren<{
  dashboardProps?: AnalyticsDashboardProps;
}>) {
  const searchParams = useSearchParams();
  const { slug: workspaceSlug, plan: workspacePlan, domains } = useWorkspace();

  const [requiresUpgrade, setRequiresUpgrade] = useState(false);

  const { dashboardId } = useParams() as {
    dashboardId?: string;
  };

  const domainSlug = searchParams?.get("domain");

  // Show conversion tabs/data for all dashboards except shared (unless explicitly set)
  const showConversions =
    !dashboardProps || dashboardProps?.showConversions ? true : false;

  const [persistedSaleUnit, setPersistedSaleUnit] =
    useLocalStorage<AnalyticsSaleUnit>(`analytics-sale-unit`, "saleAmount");

  const saleUnit: AnalyticsSaleUnit = useMemo(() => {
    const searchParamsSaleUnit = searchParams.get(
      "saleUnit",
    ) as AnalyticsSaleUnit;
    if (ANALYTICS_SALE_UNIT.includes(searchParamsSaleUnit)) {
      setPersistedSaleUnit(searchParamsSaleUnit);
      return searchParamsSaleUnit;
    }
    return persistedSaleUnit;
  }, [searchParams.get("saleUnit")]);

  const [persistedView, setPersistedView] = useLocalStorage<AnalyticsView>(
    `analytics-view`,
    "timeseries",
  );
  const view: AnalyticsView = useMemo(() => {
    const searchParamsView = searchParams.get("view") as AnalyticsView;
    if (ANALYTICS_VIEWS.includes(searchParamsView)) {
      setPersistedView(searchParamsView);
      return searchParamsView;
    }

    return ANALYTICS_VIEWS.includes(persistedView)
      ? persistedView
      : "timeseries";
  }, [searchParams.get("view")]);

  const { basePath, domain, baseApiPath, eventsApiPath } = useMemo(() => {
    if (workspaceSlug) {
      return {
        basePath: `/${workspaceSlug}/analytics`,
        baseApiPath: "/api/analytics",
        eventsApiPath: "/api/events",
        domain: domainSlug,
      };
    } else if (dashboardId) {
      // Public stats page, e.g. app.dub.co/share/dsh_123
      return {
        basePath: `/share/${dashboardId}`,
        baseApiPath: "/api/analytics/dashboard",
        domain: dashboardProps?.domain ?? null,
      };
    } else {
      return {
        basePath: "",
        baseApiPath: "",
        domain: "", // TODO [refactor]
      };
    }
  }, [workspaceSlug, dashboardProps?.domain, dashboardId, domainSlug]);

  const {
    queryString,
    key,
    start,
    end,
    interval,
    tagId,
    folderId,
    selectedTab,
  } = useAnalyticsQuery({
    domain: domain ?? undefined,
    defaultKey: dashboardProps?.key,
    defaultFolderId: dashboardProps?.folderId,
    defaultInterval: DUB_LINKS_ANALYTICS_INTERVAL,
  });

  // Reset requiresUpgrade when query changes
  useEffect(() => setRequiresUpgrade(false), [queryString]);

  const { canTrackConversions } = getPlanCapabilities(workspacePlan);

  const fetchCompositeStats = useMemo(() => {
    // show composite stats if:
    // - shared dashboard and show conversions is set to true
    // - it's a workspace that has tracked conversions/customers/leads before
    return dashboardProps?.showConversions || canTrackConversions === true
      ? true
      : false;
  }, [dashboardProps?.showConversions, canTrackConversions]);

  const { data: totalEvents, isLoading: totalEventsLoading } = useSWR<{
    [key in AnalyticsResponseOptions]: number;
  }>(
    `${baseApiPath}?${editQueryString(queryString, {
      event: fetchCompositeStats ? "composite" : "clicks",
    })}`,
    fetcher,
    {
      keepPreviousData: true,
      onSuccess: () => setRequiresUpgrade(false),
      onError: (error) => {
        try {
          const errorMessage = error.message;
          if (
            error.status === 403 &&
            errorMessage.toLowerCase().includes("upgrade")
          ) {
            toast.custom(() => (
              <UpgradeRequiredToast
                title="Upgrade for more analytics"
                message={errorMessage}
              />
            ));
            setRequiresUpgrade(true);
          } else {
            toast.error(errorMessage);
          }
        } catch (error) {
          toast.error(error);
        }
      },
      onErrorRetry: (error, ...args) => {
        if (error.message.includes("Upgrade to Pro")) return;
        defaultConfig.onErrorRetry(error, ...args);
      },
    },
  );

  return (
    <AnalyticsContext.Provider
      value={{
        basePath, // basePath for the page (e.g. /[slug]/analytics, /share/[dashboardId])
        baseApiPath, // baseApiPath for analytics API endpoints (e.g. /api/analytics)
        selectedTab, // selected event tab (clicks, leads, sales)
        eventsApiPath, // eventsApiPath for events API endpoints (e.g. /api/events)
        saleUnit,
        view,
        queryString,
        domain: domain || undefined, // domain for the link (e.g. dub.sh, stey.me, etc.)
        key: key ? decodeURIComponent(key) : undefined, // link key (e.g. github, weathergpt, etc.)
        url: dashboardProps?.url, // url for the link (only for public stats pages)
        folderId: folderId || undefined, // id of the folder(s) to filter by
        tagId, // ids of the tag(s) to filter by
        start, // start of time period
        end, // end of time period
        interval, /// time period interval
        totalEvents, // totalEvents (clicks, leads, sales)
        totalEventsLoading: totalEventsLoading,
        showConversions, // whether to show conversions tabs/data
        fetchCompositeStats, // whether to pull composite stats or just clicks
        requiresUpgrade, // whether an upgrade is required to perform the query
        dashboardProps,
      }}
    >
      {children}
    </AnalyticsContext.Provider>
  );
}