Workspace Subscriptions

Copyif (workspace.plan === "enterprise") {
  throw new DubApiError({
    code: "forbidden",
    message:
      "Since you're on an Enterprise plan, billing is managed by your account team. Please reach out to them to manage your subscription.",
  });
}
 
try {
  const { url } = await stripe.billingPortal.sessions.create({
    customer: workspace.stripeId,
    configuration: "bpc_1UEvGVAlJJEpqkPVpP38ZUNj", // custom configuration for changing billing info only
    return_url: `${APP_DOMAIN}/${workspace.slug}/settings/billing`,
  });

Copyconst upgradePlanSchema = z.object({
  plan: z.enum(["pro", "business", "advanced"]),
  period: z.enum(["monthly", "yearly"]),
  tier: z.number().min(1).max(3).optional().default(1),
  baseUrl: z.string().refine((url) => url.startsWith(APP_DOMAIN), {
    message: "Invalid baseUrl.",
  }),
  onboarding: booleanQuerySchema.nullish(),
});

Copyconst [paymentMethods, customer] = await Promise.all([
  stripe.paymentMethods.list({
    customer: workspace.stripeId,
  }),
  stripe.customers.retrieve(workspace.stripeId),
]);
 
const pendingMicrodeposits = await listPendingMicrodeposits(
  workspace.stripeId,
).catch(() => []);
 
const defaultPaymentMethod =
  customer.deleted !== true
    ? customer.invoice_settings?.default_payment_method
    : null;
 
const defaultPaymentMethodId =
  typeof defaultPaymentMethod === "string"
    ? defaultPaymentMethod
    : defaultPaymentMethod?.id ?? null;
 
const methods = withMicrodepositStatus({
  paymentMethods: paymentMethods.data,
  pendingMicrodeposits,
});
 
// reorder to put direct debit first
const directDebit = methods.find((method) =>
  DIRECT_DEBIT_PAYMENT_METHOD_TYPES.includes(method.type),
);
 
return NextResponse.json({
  paymentMethods: [
    ...(directDebit ? [directDebit] : []),
    ...methods.filter((method) => method.id !== directDebit?.id),
  ],
  defaultPaymentMethodId,
});

Copyconst querySchema = z.object({
  type: z
    .enum(["subscription", "partnerPayout", "domainRenewal"])
    .optional()
    .default("subscription"),
  stripeStatus: z.enum(["open"]).optional(), // only for Stripe subscription invoices
});

Copyconst { data: trialingSubs } = await stripe.subscriptions.list({
  customer: workspace.stripeId,
  status: "trialing",
  limit: 1,
});
const trialingSubscription = trialingSubs[0];
 
if (trialingSubscription) {
  await stripe.subscriptions.update(trialingSubscription.id, {
    trial_end: "now",
    cancel_at_period_end: false,
  });
  return NextResponse.json({ ok: true });
}

Copyexport const POST = withAxiom(async (req: Request) => {
  const buf = await req.text();
  const sig = req.headers.get("Stripe-Signature") as string;
  const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
  let event: Stripe.Event;
  try {
    if (!sig || !webhookSecret) {
      return logAndRespond("Invalid request", { status: 400 });
    }
    event = stripe.webhooks.constructEvent(buf, sig, webhookSecret);
  } catch (err: any) {
    console.log(`❌ Error message: ${err.message}`);
    return new Response(`Webhook Error: ${err.message}`, {
      status: 400,
    });
  }

Copyexport async function customerSubscriptionUpdated(
  event: Stripe.CustomerSubscriptionUpdatedEvent,
) {
  const updatedSubscription = event.data.object;
  const priceId = updatedSubscription.items.data[0].price.id;
 
  if (
    ![
      "active",
      "trialing",
      "past_due", // special case for handling past_due subscriptions (after a free trial)
    ].includes(updatedSubscription.status)
  ) {
    return `Invalid updated subscription status "${updatedSubscription.status}" for subscription ${updatedSubscription.id}, skipping...`;
  }
 
  const stripeId = updatedSubscription.customer.toString();
 
  const workspace = await prisma.project.findUnique({
    where: {
      stripeId,
    },
    include: {
      users: {
        select: {
          user: {
            select: {
              email: true,
              name: true,
            },
          },
        },
        where: {
          role: "owner",
          user: {
            isMachine: false,
          },
        },
      },
      restrictedTokens: {
        select: {
          hashedKey: true,
        },
      },
    },
  });

Copyawait updateWorkspacePlan({
  workspace,
  priceId,
  subscription: updatedSubscription,
});
 
if (updatedSubscription.cancel_at_period_end) {
  const owners = workspace.users.map(({ user }) => user);
  const cancelReason = updatedSubscription.cancellation_details?.feedback;
 
  await sendCancellationFeedback({
    workspace,
    owners,
    reason: cancelReason,
  });
  return `Sent cancellation feedback to ${owners.length} workspace owners for workspace ${workspace.slug}.`;
}

Copyif (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.";
}

Copyexport function getWorkspaceLimitsFromStripeSubscription({
  planLimits,
  subscription,
}: {
  planLimits: PlanDetails["limits"];
  subscription: Stripe.Subscription;
}): PlanDetails["limits"] {
  if (subscription.status !== "trialing") {
    const subscriptionPeriod =
      getPlanPeriodFromStripeSubscription(subscription);
    return {
      ...planLimits,
      ...(subscriptionPeriod === "yearly"
        ? {
            clicks: planLimits.clicks * 12,
            links: planLimits.links * 12,
            payouts: planLimits.payouts * 12,
            ai: planLimits.ai * 12,
          }
        : {}),
    };
  }
 
  return {
    ...planLimits,
    links: TRIAL_LIMITS.links,
    clicks: TRIAL_LIMITS.clicks,
    payouts: TRIAL_LIMITS.payouts,
    users: TRIAL_LIMITS.users,
    domains: TRIAL_LIMITS.domains,
    tags: TRIAL_LIMITS.tags,
    partnerTags: TRIAL_LIMITS.partnerTags,
    folders: TRIAL_LIMITS.folders,
    groups: TRIAL_LIMITS.groups,
    networkInvites: TRIAL_LIMITS.networkInvites,
    partners: TRIAL_LIMITS.partners,
    ai: TRIAL_LIMITS.ai,
    api: TRIAL_LIMITS.api,
    analyticsApi: TRIAL_LIMITS.analyticsApi,
  };

Copyconst isYearlyToMonthly =
  workspace.planPeriod === "yearly" && planPeriod === "monthly";
 
const recomputedUsage = isYearlyToMonthly
  ? await recomputeWorkspaceUsage(workspace)
  : null;
 

Copyexport async function recomputeWorkspaceUsage(
  workspace: Pick<Project, "id" | "billingCycleStart">,
) {
  const billingStart = getBillingStartDate(workspace.billingCycleStart);
  const billingEnd = new Date();
 

Copyconst [clicksData, linksData, payoutsUsage] = await Promise.all([
  getWorkspaceUsage({
    workspaceId: workspace.id,
    resource: "events",
    start: billingStart,
    end: billingEnd,
  }),
 
  getWorkspaceUsage({
    workspaceId: workspace.id,
    resource: "links",
    start: billingStart,
    end: billingEnd,
  }),
 
  prisma.invoice.aggregate({
    where: {
      workspaceId: workspace.id,
      type: "partnerPayout",
      status: "completed",
      paidAt: {
        gte: billingStart,
        lte: billingEnd,
      },
    },
    _sum: {
      amount: true,
    },
  }),
]);

Copyexport async function invoicePaymentFailed(
  event: Stripe.InvoicePaymentFailedEvent,
) {
  const {
    customer: stripeId,
    attempt_count: attemptCount,
    amount_due: amountDue,
  } = event.data.object;
 
  if (!stripeId) {
    return "No customer found in invoice.payment_failed event.";
  }
 
  const workspace = await prisma.project.findUnique({
    where: {
      stripeId: stripeId.toString(),
    },
    select: {
      id: true,
      name: true,
      slug: true,
      plan: true,
      defaultProgramId: true,
      users: {
        select: {
          user: {
            select: {
              name: true,
              email: true,
            },
          },
        },
        where: {
          user: {
            isMachine: false,
          },
        },
      },
    },
  });

Copyexport async function chargeDisputeCreated(
  event: Stripe.ChargeDisputeCreatedEvent,
) {
  const dispute = event.data.object;
  const chargeId =
    typeof dispute.charge === "string" ? dispute.charge : dispute.charge.id;
 
  const charge = await stripe.charges.retrieve(chargeId, {
    expand: ["customer"],
  });
 
  const { customer: customerObj, payment_method_details } = charge;
  const customer = customerObj as Stripe.Customer;
 
  const workspace = await prisma.project.findUnique({
    where: {
      stripeId: customer.id,
    },
  });
 
  // should never happen, but just in case
  if (!workspace) {
    return `Workspace with stripeId ${customer.id} not found.`;
  }

Copyawait disableWorkspaceLinks(workspace.id);
 
// Update all users to viewer role except for LEGAL_USER_ID
const updatedUsers = await prisma.projectUsers.updateMany({
  where: {
    projectId: workspace.id,
    userId: {
      not: LEGAL_USER_ID,
    },
  },
  data: {
    role: "viewer",
  },
});
 
console.log(`Updated ${updatedUsers.count} users to viewer role`);
 
// Add LEGAL_USER_ID as owner
await prisma.projectUsers.upsert({
  where: {
    userId_projectId: {
      projectId: workspace.id,
      userId: LEGAL_USER_ID,
    },
  },
  update: {
    role: "owner",
  },
  create: {
    projectId: workspace.id,
    userId: LEGAL_USER_ID,
    role: "owner",
  },
});
 
console.log(
  `Added legal user ${LEGAL_USER_ID} as owner to workspace ${workspace.id}`,
);
 
await prisma.project.update({
  where: {
    id: workspace.id,
  },
  data: {
    disabledAt: new Date(),
  },
});
 
await addToStripeFraudValueLists({
  customerId: customer.id,
  customerEmail: customer.email,
  cardFingerprint: payment_method_details?.card?.fingerprint,
});
 
await cancelSubscription({
  customerId: customer.id,
  reason: "Workspace banned due to charge dispute",
});
 

Copyexport default function PlanUsage() {
  const {
    id: workspaceId,
    slug,
    plan,
    role,
    stripeId,
    usage,
    usageLimit,
    linksUsage,
    linksLimit,
    totalLinks,
    payoutsUsage,
    payoutsLimit,
    payoutFee,
    payoutFeeWaiverLimit,
    payoutFeeWaiverUsage,
    domains,
    domainsLimit,
    foldersUsage,
    foldersLimit,
    partnersUsage,
    partnersLimit,
    groupsLimit,
    tagsLimit,
    usersLimit,
    billingCycleStart,
    planPeriod,
    trialEndsAt,
    subscriptionCanceledAt,
    billingCycleEndsAt,
    defaultProgramId,
    loading,
    mutate,
  } = useWorkspace();

Copyexport default function SubscriptionMenu() {
  const {
    id: workspaceId,
    role,
    plan,
    defaultProgramId,
    billingCycleEndsAt,
    subscriptionCanceledAt,
    mutate,
  } = useWorkspace();
  const router = useRouter();
 
  const permissionsError = clientAccessCheck({
    action: "billing.write",
    role,
  }).error;
 
  const [isOpen, setIsOpen] = useState(false);
  const [clicked, setClicked] = useState(false);
 
  const openBillingPortal = async () => {
    setIsOpen(false);
    setClicked(true);
    return fetch(`/api/workspaces/${workspaceId}/billing/manage`, {
      method: "POST",
    })
      .then(async (res) => {
        if (res.ok) {
          const { url } = await res.json();
          router.push(url);
        } else {
          const { error } = await res.json();
          toast.error(error.message);
        }
      })
      .finally(() => {
        setClicked(false);
      });
  };

Copy// Check if canceling would lose partner access
const losesPartnerAccess =
  plan &&
  defaultProgramId &&
  wouldLosePartnerAccess({ currentPlan: plan, newPlan: null });
 
const { setShowCancelSubscriptionModal, CancelSubscriptionModal } =
  useCancelSubscriptionModal({
    billingCycleEndsAt,
    onConfirm: handleCancellation,
  });
 
const { setShowPlanChangeConfirmationModal, PlanChangeConfirmationModal } =
  usePlanChangeConfirmationModal({
    newPlan: "free",
    newPeriod: "monthly",
    newTier: 1,
    onConfirm: async () => {
      setShowPlanChangeConfirmationModal(false);
      setShowCancelSubscriptionModal(true);
    },
  });
 
const handleCancelSubscription = () => {
  setIsOpen(false);
  if (losesPartnerAccess) {
    setShowPlanChangeConfirmationModal(true);
  } else {
    setShowCancelSubscriptionModal(true);
  }
};

Copyexport async function POST(req: NextRequest) {
  // authenticate webhook X-Plain-Webhook-Secret
  const token = req.headers.get("X-Plain-Webhook-Secret");
  if (token !== process.env.PLAIN_WEBHOOK_SECRET) {
    return new Response("Unauthorized", { status: 401 });
  }

Copylet { customer } = plainCallbackSchema.parse(await req.json());
 
const user = await prisma.user.findUnique({
  where: customer.externalId
    ? { id: customer.externalId }
    : { email: customer.email },
});
 
if (!user || !user.email) {
  const isBannedUser = await isBlacklistedEmail(customer.email);
  if (isBannedUser) {
    await plain.addCustomerToCustomerGroups({
      customerId: customer.id,
      customerGroupIdentifiers: [
        {
          customerGroupKey: "banned_users",
        },
      ],
    });
  }
 
  return NextResponse.json({
    cards: [
      {
        key: "workspace",
        components: [plainEmptyContainer("No user found.")],
      },
    ],
  });
}
 
if (!customer.externalId) {
  customer.externalId = user.id;
  await upsertPlainCustomer({
    id: user.id,
    name: user.name,
    email: user.email,
  });
}
 
waitUntil(syncUserPlanToPlain(user));
 
const topWorkspace = await prisma.project.findFirst({
  where: {
    users: {
      some: {
        userId: customer.externalId,
      },
    },
  },
  include: {
    _count: {
      select: {
        domains: true,
        users: true,
      },
    },
  },
  orderBy: {
    usageLimit: "desc",
  },
  take: 1,
});