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.1 KB
Raw Blame
import { claimDotLinkDomain } from "@/lib/api/domains/claim-dot-link-domain";
import { onboardingStepCache } from "@/lib/api/workspaces/onboarding-step-cache";
import { tokenCache } from "@/lib/auth/token-cache";
import { prisma } from "@/lib/prisma";
import { stripe } from "@/lib/stripe";
import { getSubscriptionBillingFields } from "@/lib/stripe/workspace-subscription-fields";
import { redis } from "@/lib/upstash";
import { sendBatchEmail } from "@dub/email";
import TrialStartedEmail from "@dub/email/templates/trial/trial-started";
import { getPlanAndTierFromPriceId, log } from "@dub/utils";
import { User } from "@prisma/client";
import Stripe from "stripe";
import { getPlanPeriodFromStripeSubscription } from "./utils/get-plan-period-from-stripe-subscription";
import { getWorkspaceLimitsFromStripeSubscription } from "./utils/get-workspace-limits-from-stripe-subscription";

export async function checkoutSessionCompleted(
  event: Stripe.CheckoutSessionCompletedEvent,
) {
  const checkoutSession = event.data.object;

  if (checkoutSession.mode === "setup") {
    return "Session is setup mode, skipping...";
  }

  if (checkoutSession.mode === "subscription") {
    if (
      checkoutSession.payment_status !== "paid" &&
      checkoutSession.payment_status !== "no_payment_required"
    ) {
      return "Subscription checkout session not completed (payment status), skipping...";
    }
  } else {
    return `Session mode ${checkoutSession.mode} is not handled here, skipping...`;
  }

  if (
    checkoutSession.client_reference_id === null ||
    checkoutSession.customer === null
  ) {
    await log({
      message: "Missing items in Stripe webhook callback",
      type: "errors",
    });
    return "Missing client_reference_id or customer in checkout session.";
  }

  const subscription = await stripe.subscriptions.retrieve(
    checkoutSession.subscription as string,
  );
  const priceId = subscription.items.data[0].price.id;

  const { plan, planTier } = getPlanAndTierFromPriceId({ priceId });

  if (!plan) {
    return `Invalid price ID in checkout.session.completed event: ${priceId}`;
  }

  const trialEndsAt =
    subscription.status === "trialing" && subscription.trial_end
      ? new Date(subscription.trial_end * 1000)
      : null;

  const stripeId = checkoutSession.customer.toString();
  const workspaceId = checkoutSession.client_reference_id;
  const planName = plan.name.toLowerCase();
  const planPeriod = getPlanPeriodFromStripeSubscription(subscription);

  const limits = getWorkspaceLimitsFromStripeSubscription({
    planLimits: plan.limits,
    subscription,
  });

  // when the workspace subscribes to a plan, set their stripe customer ID
  // in the database for easy identification in future webhook events
  // also update the billingCycleStart to today's date

  const updatedWorkspace = await prisma.project.update({
    where: {
      id: workspaceId,
    },
    data: {
      stripeId,
      billingCycleStart: new Date().getDate(),
      plan: planName,
      planTier: planTier,
      usageLimit: limits.clicks,
      linksLimit: limits.links,
      domainsLimit: limits.domains,
      aiLimit: limits.ai,
      tagsLimit: limits.tags,
      foldersLimit: limits.folders,
      usersLimit: limits.users,
      trialEndsAt,
      paymentFailedAt: null,
      ...(planPeriod !== undefined && { planPeriod }),
      ...getSubscriptionBillingFields(subscription),
    },
    include: {
      users: {
        where: {
          role: "owner",
          user: {
            isMachine: false,
          },
        },
        select: {
          user: {
            select: {
              id: true,
              name: true,
              email: true,
            },
          },
        },
      },
      restrictedTokens: {
        select: {
          hashedKey: true,
        },
      },
    },
  });

  const users = updatedWorkspace.users.map(({ user }) => ({
    id: user.id,
    name: user.name,
    email: user.email,
  }));

  await Promise.allSettled([
    completeOnboarding({ users, workspaceId, subscription }),

    subscription.status === "trialing" &&
      sendBatchEmail(
        users.map((user) => ({
          to: user.email as string,
          replyTo: "[email protected]",
          subject: "Welcome to your 14-day Dub trial",
          react: TrialStartedEmail({
            email: user.email as string,
            plan: plan.name,
            workspace: {
              slug: updatedWorkspace.slug,
              logo: updatedWorkspace.logo,
              name: updatedWorkspace.name,
            },
          }),
          variant: "marketing",
        })),
      ),
    // expire tokens cache
    tokenCache.expireMany({
      hashedKeys: updatedWorkspace.restrictedTokens.map(
        ({ hashedKey }) => hashedKey,
      ),
    }),
  ]);

  return `Checkout completed for workspace ${workspaceId}, upgraded to ${plan.name}.`;
}

async function completeOnboarding({
  workspaceId,
  users,
  subscription,
}: {
  workspaceId: string;
  users: Pick<User, "id" | "email">[];
  subscription: Pick<Stripe.Subscription, "status">;
}) {
  const workspace = await prisma.project.findUnique({
    where: {
      id: workspaceId,
    },
  });

  if (!workspace) {
    console.error(
      "Failed to find workspace in completeOnboarding",
      workspaceId,
    );
    return;
  }

  await Promise.allSettled([
    onboardingStepCache.mset({
      userIds: users.map(({ id }) => id),
      step: "completed",
    }),

    // Claim saved domain (only if subscription is active)
    subscription.status === "active" &&
      (async () => {
        // Register saved domain
        const data = await redis.get<{ domain: string; userId: string }>(
          `onboarding-domain:${workspaceId}`,
        );
        if (data && data.domain && data.userId) {
          const { domain, userId } = data;

          await claimDotLinkDomain({
            domain,
            userId,
            workspace,
          }).catch((error) => {
            console.error(
              "Failed to claim saved domain in completeOnboarding",
              error,
            );
            return;
          });
        }
      })(),
  ]);
}