Free Trial

.github/workflows/playwright.yaml

@@ -112,6 +112,10 @@ jobs:
       - name: Check out code
         uses: actions/checkout@v4
 
+      # Linux runners do not always resolve *.localhost reliably; E2E uses partners + app subdomains.
+      - name: Map *.localhost subdomains to loopback
+        run: echo '127.0.0.1 partners.localhost app.localhost' | sudo tee -a /etc/hosts
+
       - name: Start PlanetScale simulator
         run: |
           docker run -d --name ps-http-sim \

apps/web/app/(ee)/api/cron/trial-emails/route.ts

@@ -0,0 +1,66 @@
+import { qstash } from "@/lib/cron";
+import { withCron } from "@/lib/cron/with-cron";
+import { runTrialEmailCron } from "@/lib/email/run-trial-email-cron";
+import { prisma } from "@dub/prisma";
+import { APP_DOMAIN_WITH_NGROK } from "@dub/utils";
+import * as z from "zod/v4";
+import { logAndRespond } from "../utils";
+
+export const dynamic = "force-dynamic";
+
+const QSTASH_CONTINUATION_DELAY_SECONDS = 2;
+
+const postBodySchema = z.object({
+  startingAfter: z.string(),
+});
+
+/**
+ * Sends the paid-plan trial marketing sequence (see `lib/email/trial-email-schedule.ts`).
+ * Runs on a schedule (cron). Eligibility is `trialEndsAt` in the future + `SentEmail` dedupe.
+ *
+ * Complements the generic welcome email (`/api/cron/welcome-user`): free-only signups get welcome only;
+ * users who start a trial get welcome (QStash) + these emails when due.
+ */
+
+async function executeTrialEmailCronPage(startingAfter?: string) {
+  const now = new Date();
+  const result = await runTrialEmailCron({
+    now,
+    prisma,
+    startingAfter,
+  });
+
+  if (result.workspaceCount === 0) {
+    if (startingAfter) {
+      return logAndRespond(
+        "Trial email cron: no workspaces on continuation page (done).",
+      );
+    }
+
+    return logAndRespond("No workspaces in active trial. Skipping.");
+  }
+
+  if (result.hasMore && result.nextStartingAfter) {
+    await qstash.publishJSON({
+      url: `${APP_DOMAIN_WITH_NGROK}/api/cron/trial-emails`,
+      method: "POST",
+      delay: QSTASH_CONTINUATION_DELAY_SECONDS,
+      body: {
+        startingAfter: result.nextStartingAfter,
+      },
+    });
+  }
+
+  return logAndRespond(
+    `Trial email cron: sent ${result.sentCount} email(s) for ${result.workspaceCount} workspace(s)${result.hasMore ? "; next page enqueued." : "."}`,
+  );
+}
+
+// GET /api/cron/trial-emails
+export const GET = withCron(async () => executeTrialEmailCronPage(undefined));
+
+// POST /api/cron/trial-emails (QStash continuation)
+export const POST = withCron(async ({ rawBody }) => {
+  const { startingAfter } = postBodySchema.parse(JSON.parse(rawBody));
+  return await executeTrialEmailCronPage(startingAfter);
+});

apps/web/app/(ee)/api/cron/welcome-user/route.ts

@@ -13,6 +13,9 @@ export const dynamic = "force-dynamic";
 /*
     This route is used to send a welcome email to new users + subscribe them to the corresponding Resend audience
     It is called by QStash 45 minutes after a user is created.
+
+    Trial sequence: users who later start a paid-plan trial also receive marketing emails from
+    `/api/cron/trial-emails` when due; that flow is additive (this welcome is not skipped).
 */
 export async function POST(req: Request) {
   try {

apps/web/app/(ee)/api/stripe/webhook/checkout-session-completed.ts

@@ -9,17 +9,31 @@ import { sendBatchEmail } from "@dub/email";
 import UpgradeEmail from "@dub/email/templates/upgrade-email";
 import { prisma } from "@dub/prisma";
 import { Program, User } from "@dub/prisma/client";
-import { getPlanAndTierFromPriceId, log, prettyPrint } from "@dub/utils";
+import {
+  getPlanAndTierFromPriceId,
+  getWorkspaceLimitsForStripeSubscriptionStatus,
+  log,
+  prettyPrint,
+} from "@dub/utils";
 import Stripe from "stripe";
+import { getPlanPeriodFromStripeSubscription } from "./utils/stripe-plan-period";
 
 export async function checkoutSessionCompleted(event: Stripe.Event) {
   const checkoutSession = event.data.object as Stripe.Checkout.Session;
 
-  if (
-    checkoutSession.mode === "setup" ||
-    checkoutSession.payment_status !== "paid"
-  ) {
-    return "Session is setup mode or not paid, skipping...";
+  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 (
@@ -44,9 +58,20 @@ export async function checkoutSessionCompleted(event: Stripe.Event) {
     return `Invalid price ID in checkout.session.completed event: ${priceId}`;
   }
 
+  const limits = getWorkspaceLimitsForStripeSubscriptionStatus({
+    planLimits: plan.limits,
+    subscriptionStatus: subscription.status,
+  });
+
+  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);
 
   // when the workspace subscribes to a plan, set their stripe customer ID
   // in the database for easy identification in future webhook events
@@ -61,17 +86,19 @@ export async function checkoutSessionCompleted(event: Stripe.Event) {
       billingCycleStart: new Date().getDate(),
       plan: planName,
       planTier: planTier,
-      usageLimit: plan.limits.clicks,
-      linksLimit: plan.limits.links,
-      payoutsLimit: plan.limits.payouts,
-      domainsLimit: plan.limits.domains,
-      aiLimit: plan.limits.ai,
-      tagsLimit: plan.limits.tags,
-      foldersLimit: plan.limits.folders,
-      groupsLimit: plan.limits.groups,
-      networkInvitesLimit: plan.limits.networkInvites,
-      usersLimit: plan.limits.users,
+      usageLimit: limits.clicks,
+      linksLimit: limits.links,
+      payoutsLimit: limits.payouts,
+      domainsLimit: limits.domains,
+      aiLimit: limits.ai,
+      tagsLimit: limits.tags,
+      foldersLimit: limits.folders,
+      groupsLimit: limits.groups,
+      networkInvitesLimit: limits.networkInvites,
+      usersLimit: limits.users,
+      trialEndsAt,
       paymentFailedAt: null,
+      ...(planPeriod !== undefined && { planPeriod }),
     },
     select: {
       plan: true,
@@ -122,15 +149,19 @@ export async function checkoutSessionCompleted(event: Stripe.Event) {
         variant: "marketing",
       })),
     ),
-    // enable dub.link premium default domain for the workspace
-    prisma.defaultDomains.update({
-      where: {
-        projectId: workspaceId,
-      },
-      data: {
-        dublink: true,
-      },
-    }),
+    // enable dub.link premium default domain for the workspace (not during billing trial)
+    ...(subscription.status !== "trialing"
+      ? [
+          prisma.defaultDomains.update({
+            where: {
+              projectId: workspaceId,
+            },
+            data: {
+              dublink: true,
+            },
+          }),
+        ]
+      : []),
     // expire tokens cache
     tokenCache.expireMany({
       hashedKeys: workspace.restrictedTokens.map(({ hashedKey }) => hashedKey),

apps/web/app/(ee)/api/stripe/webhook/customer-subscription-deleted.ts

@@ -1,10 +1,17 @@
+import { pauseOrCancelCampaignsForProgramOnPlanDowngrade } from "@/lib/api/campaigns/pause-campaigns-on-plan-downgrade";
 import { deleteWorkspaceFolders } from "@/lib/api/folders/delete-workspace-folders";
 import { linkCache } from "@/lib/api/links/cache";
 import { includeProgramEnrollment } from "@/lib/api/links/include-program-enrollment";
 import { includeTags } from "@/lib/api/links/include-tags";
+import { stripAdvancedRewardModifiersForProgram } from "@/lib/api/partners/strip-advanced-reward-modifiers";
 import { deactivateProgram } from "@/lib/api/programs/deactivate-program";
 import { tokenCache } from "@/lib/auth/token-cache";
 import { isBlacklistedEmail } from "@/lib/edge-config/is-blacklisted-email";
+import { sendAdvancedDowngradeNoticeEmailIfNeeded } from "@/lib/email/send-advanced-downgrade-notice-email";
+import {
+  leftAdvancedPlan,
+  wouldLoseAdvancedRewardLogic,
+} from "@/lib/plans/has-advanced-features";
 import { stripe } from "@/lib/stripe";
 import { recordLink } from "@/lib/tinybird";
 import { webhookCache } from "@/lib/webhook/cache";
@@ -27,10 +34,12 @@ export async function customerSubscriptionDeleted(event: Stripe.Event) {
     },
     select: {
       id: true,
+      name: true,
       slug: true,
       plan: true,
       planTier: true,
       foldersUsage: true,
+      subscriptionCanceledAt: true,
       paymentFailedAt: true,
       payoutsLimit: true,
       defaultProgramId: true,
@@ -71,22 +80,32 @@ export async function customerSubscriptionDeleted(event: Stripe.Event) {
     return `Workspace with Stripe ID ${stripeId} not found in customer.subscription.deleted callback.`;
   }
 
-  // Check if the customer has another active subscription
-  const { data: activeSubscriptions } = await stripe.subscriptions.list({
-    customer: stripeId,
-    status: "active",
-  });
+  // Check if the customer has another subscription still in force (active or trialing)
+  const [{ data: activeSubscriptions }, { data: trialingSubscriptions }] =
+    await Promise.all([
+      stripe.subscriptions.list({
+        customer: stripeId,
+        status: "active",
+      }),
+      stripe.subscriptions.list({
+        customer: stripeId,
+        status: "trialing",
+      }),
+    ]);
+
+  const fallbackSubscription =
+    activeSubscriptions[0] ?? trialingSubscriptions[0];
 
-  if (activeSubscriptions.length > 0) {
-    const activeSubscription = activeSubscriptions[0];
-    const priceId = activeSubscription.items.data[0].price.id;
+  if (fallbackSubscription) {
+    const priceId = fallbackSubscription.items.data[0].price.id;
 
     await updateWorkspacePlan({
       workspace,
       priceId,
+      subscription: fallbackSubscription,
     });
 
-    return `Workspace ${workspace.slug} has another active subscription; updated plan.`;
+    return `Workspace ${workspace.slug} has another subscription; updated plan.`;
   }
 
   const workspaceLinks = workspace.links;
@@ -96,27 +115,33 @@ export async function customerSubscriptionDeleted(event: Stripe.Event) {
     workspaceUsers.filter(({ email }) => email).map(({ email }) => email!),
   );
 
-  await Promise.allSettled([
-    prisma.project.update({
-      where: {
-        stripeId,
-      },
-      data: {
-        plan: "free",
-        usageLimit: FREE_PLAN.limits.clicks!,
-        linksLimit: FREE_PLAN.limits.links!,
-        payoutsLimit: FREE_PLAN.limits.payouts!,
-        domainsLimit: FREE_PLAN.limits.domains!,
-        aiLimit: FREE_PLAN.limits.ai!,
-        tagsLimit: FREE_PLAN.limits.tags!,
-        foldersLimit: FREE_PLAN.limits.folders!,
-        groupsLimit: FREE_PLAN.limits.groups!,
-        networkInvitesLimit: FREE_PLAN.limits.networkInvites!,
-        usersLimit: FREE_PLAN.limits.users!,
-        paymentFailedAt: null,
-      },
-    }),
+  await prisma.project.update({
+    where: {
+      stripeId,
+    },
+    data: {
+      plan: "free",
+      trialEndsAt: null,
+      planPeriod: null,
+      billingCycleEndsAt: null,
+      subscriptionCanceledAt: workspace.subscriptionCanceledAt
+        ? undefined
+        : new Date(),
+      usageLimit: FREE_PLAN.limits.clicks!,
+      linksLimit: FREE_PLAN.limits.links!,
+      payoutsLimit: FREE_PLAN.limits.payouts!,
+      domainsLimit: FREE_PLAN.limits.domains!,
+      aiLimit: FREE_PLAN.limits.ai!,
+      tagsLimit: FREE_PLAN.limits.tags!,
+      foldersLimit: FREE_PLAN.limits.folders!,
+      groupsLimit: FREE_PLAN.limits.groups!,
+      networkInvitesLimit: FREE_PLAN.limits.networkInvites!,
+      usersLimit: FREE_PLAN.limits.users!,
+      paymentFailedAt: null,
+    },
+  });
 
+  await Promise.allSettled([
     // disable dub.link premium default domain for the workspace
     prisma.defaultDomains.update({
       where: {
@@ -229,5 +254,39 @@ export async function customerSubscriptionDeleted(event: Stripe.Event) {
     await deactivateProgram(workspace.defaultProgramId);
   }
 
+  if (
+    workspace.defaultProgramId &&
+    wouldLoseAdvancedRewardLogic({
+      currentPlan: workspace.plan,
+      newPlan: "free",
+    })
+  ) {
+    await Promise.all([
+      stripAdvancedRewardModifiersForProgram({
+        programId: workspace.defaultProgramId,
+      }),
+      pauseOrCancelCampaignsForProgramOnPlanDowngrade({
+        programId: workspace.defaultProgramId,
+      }),
+    ]);
+  }
+
+  const owner = workspaceUsers[0];
+  if (
+    owner &&
+    leftAdvancedPlan({
+      currentPlan: workspace.plan,
+      newPlan: "free",
+    })
+  ) {
+    await sendAdvancedDowngradeNoticeEmailIfNeeded({
+      projectId: workspace.id,
+      dedupeType: `advanced-downgrade-notice:subscription-deleted:${subscriptionDeleted.id}`,
+      ownerEmail: owner.email,
+      workspaceName: workspace.name,
+      workspaceSlug: workspace.slug,
+    });
+  }
+
   return `Workspace ${workspace.slug} subscription deleted; downgraded to free.`;
 }

apps/web/app/(ee)/api/stripe/webhook/customer-subscription-updated.ts

@@ -22,6 +22,8 @@ export async function customerSubscriptionUpdated(event: Stripe.Event) {
     },
     select: {
       id: true,
+      name: true,
+      slug: true,
       plan: true,
       planTier: true,
       paymentFailedAt: true,
@@ -59,6 +61,7 @@ export async function customerSubscriptionUpdated(event: Stripe.Event) {
   await updateWorkspacePlan({
     workspace,
     priceId,
+    subscription: subscriptionUpdated,
   });
 
   const subscriptionCanceled =