one time payments

apps/backend/prisma/migrations/20250827200446_one_time_purchase/migration.sql

@@ -0,0 +1,13 @@
+-- CreateTable
+CREATE TABLE "OneTimePurchase" (
+    "id" UUID NOT NULL,
+    "tenancyId" UUID NOT NULL,
+    "customerId" TEXT NOT NULL,
+    "customerType" "CustomerType" NOT NULL,
+    "offerId" TEXT,
+    "offer" JSONB NOT NULL,
+    "quantity" INTEGER NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "OneTimePurchase_pkey" PRIMARY KEY ("tenancyId","id")
+);

apps/backend/prisma/schema.prisma

@@ -753,7 +753,7 @@ enum SubscriptionStatus {
   unpaid
 }
 
-enum SubscriptionCreationSource {
+enum PurchaseCreationSource {
   PURCHASE_PAGE
   TEST_MODE
 }
@@ -773,7 +773,7 @@ model Subscription {
   currentPeriodStart   DateTime
   cancelAtPeriodEnd    Boolean
 
-  creationSource SubscriptionCreationSource
+  creationSource PurchaseCreationSource
   createdAt      DateTime                   @default(now())
   updatedAt      DateTime                   @updatedAt
 
@@ -795,6 +795,20 @@ model ItemQuantityChange {
   @@index([tenancyId, customerId, expiresAt])
 }
 
+model OneTimePurchase {
+  id String @default(uuid()) @db.Uuid
+  tenancyId String @db.Uuid
+  customerId String
+  customerType CustomerType
+  offerId String?
+  offer Json
+  quantity Int
+  createdAt DateTime @default(now())
+  creationSource PurchaseCreationSource
+
+  @@id([tenancyId, id])
+}
+
 model DataVaultEntry {
   id        String   @default(uuid()) @db.Uuid
   tenancyId String   @db.Uuid

apps/backend/src/app/api/latest/integrations/stripe/webhooks/route.tsx

@@ -1,8 +1,12 @@
 import { getStackStripe, syncStripeSubscriptions } from "@/lib/stripe";
+import { getTenancy } from "@/lib/tenancies";
+import { getPrismaClientForTenancy } from "@/prisma-client";
 import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
 import { yupMixed, yupNumber, yupObject, yupString, yupTuple } from "@stackframe/stack-shared/dist/schema-fields";
 import { getEnvVariable } from "@stackframe/stack-shared/dist/utils/env";
 import { StackAssertionError, captureError } from "@stackframe/stack-shared/dist/utils/errors";
+import { typedToUppercase } from "@stackframe/stack-shared/dist/utils/strings";
+import { typedIncludes } from '@stackframe/stack-shared/dist/utils/arrays';
 import Stripe from "stripe";
 
 const subscriptionChangedEvents = [
@@ -30,6 +34,65 @@ const isSubscriptionChangedEvent = (event: Stripe.Event): event is Stripe.Event
   return subscriptionChangedEvents.includes(event.type as any);
 };
 
+async function processStripeWebhookEvent(event: Stripe.Event): Promise<void> {
+  if (event.type === "payment_intent.succeeded") {
+    const object = event.data.object as any;
+    const metadata = object?.metadata ?? {};
+    if (metadata.purchaseKind === "ONE_TIME") {
+      const accountId = event.account;
+      if (!accountId) {
+        throw new StackAssertionError("Stripe webhook account id missing", { event });
+      }
+      const stripe = getStackStripe();
+      const account = await stripe.accounts.retrieve(accountId);
+      const tenancyId = account.metadata?.tenancyId;
+      if (!tenancyId) {
+        throw new StackAssertionError("Stripe account metadata missing tenancyId", { event });
+      }
+      const tenancy = await getTenancy(tenancyId);
+      if (!tenancy) {
+        throw new StackAssertionError("Tenancy not found", { event });
+      }
+      const prisma = await getPrismaClientForTenancy(tenancy);
+      const offer = JSON.parse(metadata.offer || "{}");
+      const customerIdMeta: string | undefined = metadata.customerId;
+      const customerTypeMeta: string | undefined = metadata.customerType;
+      const qty = Math.max(1, Number(metadata.purchaseQuantity || 1));
+      if (!customerIdMeta || !customerTypeMeta) {
+        throw new StackAssertionError("Missing customer metadata for one-time purchase", { event });
+      }
+      if (!typedIncludes(["user", "team", "custom"] as const, customerTypeMeta)) {
+        throw new StackAssertionError("Invalid customer type for one-time purchase", { event });
+      }
+      await prisma.oneTimePurchase.create({
+        data: {
+          tenancyId: tenancy.id,
+          customerId: customerIdMeta,
+          customerType: typedToUppercase(customerTypeMeta),
+          offerId: metadata.offerId || null,
+          offer,
+          quantity: qty,
+          creationSource: "PURCHASE_PAGE",
+        },
+      });
+      return;
+    }
+  }
+
+  if (isSubscriptionChangedEvent(event)) {
+    const accountId = event.account;
+    const customerId = (event.data.object as any).customer;
+    if (!accountId) {
+      throw new StackAssertionError("Stripe webhook account id missing", { event });
+    }
+    if (typeof customerId !== 'string') {
+      throw new StackAssertionError("Stripe webhook bad customer id", { event });
+    }
+    await syncStripeSubscriptions(accountId, customerId);
+    return;
+  }
+}
+
 export const POST = createSmartRouteHandler({
   metadata: {
     hidden: true,
@@ -60,22 +123,7 @@ export const POST = createSmartRouteHandler({
         signature,
         getEnvVariable("STACK_STRIPE_WEBHOOK_SECRET"),
       );
-
-      if (event.type === "account.updated") {
-        if (!event.account) {
-          throw new StackAssertionError("Stripe webhook account id missing", { event });
-        }
-      } else if (isSubscriptionChangedEvent(event)) {
-        const accountId = event.account;
-        const customerId = (event.data.object as any).customer;
-        if (!accountId) {
-          throw new StackAssertionError("Stripe webhook account id missing", { event });
-        }
-        if (typeof customerId !== 'string') {
-          throw new StackAssertionError("Stripe webhook bad customer id", { event });
-        }
-        await syncStripeSubscriptions(accountId, customerId);
-      }
+      await processStripeWebhookEvent(event);
     } catch (error) {
       captureError("stripe-webhook-receiver", error);
     }

apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx

@@ -1,13 +1,12 @@
 import { purchaseUrlVerificationCodeHandler } from "@/app/api/latest/payments/purchases/verification-code-handler";
-import { isActiveSubscription, validatePurchaseSession } from "@/lib/payments";
+import { validatePurchaseSession } from "@/lib/payments";
 import { getStripeForAccount } from "@/lib/stripe";
-import { getPrismaClientForTenancy, retryTransaction } from "@/prisma-client";
+import { getPrismaClientForTenancy } from "@/prisma-client";
 import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
-import { SubscriptionCreationSource, SubscriptionStatus } from "@prisma/client";
+import { SubscriptionStatus } from "@prisma/client";
 import { adaptSchema, adminAuthTypeSchema, yupNumber, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
 import { addInterval } from "@stackframe/stack-shared/dist/utils/dates";
-import { StatusError } from "@stackframe/stack-shared/dist/utils/errors";
-import { typedKeys } from "@stackframe/stack-shared/dist/utils/objects";
+import { StackAssertionError, StatusError } from "@stackframe/stack-shared/dist/utils/errors";
 import { typedToUppercase } from "@stackframe/stack-shared/dist/utils/strings";
 
 export const POST = createSmartRouteHandler({
@@ -37,65 +36,50 @@ export const POST = createSmartRouteHandler({
       throw new StatusError(400, "Tenancy id does not match value from code data");
     }
     const prisma = await getPrismaClientForTenancy(auth.tenancy);
-    const { selectedPrice, groupId, subscriptions } = await validatePurchaseSession({
+
+    const { selectedPrice, conflictingGroupSubscriptions } = await validatePurchaseSession({
       prisma,
       tenancy: auth.tenancy,
       codeData: data,
       priceId: price_id,
       quantity,
     });
-    if (groupId) {
-      for (const subscription of subscriptions) {
-        if (
-          subscription.id &&
-          subscription.offerId &&
-          subscription.offer.groupId === groupId &&
-          isActiveSubscription(subscription) &&
-          subscription.offer.prices !== "include-by-default" &&
-          (!data.offer.isAddOnTo || !typedKeys(data.offer.isAddOnTo).includes(subscription.offerId))
-        ) {
-          if (!selectedPrice?.interval) {
-            continue;
-          }
-          if (subscription.stripeSubscriptionId) {
-            const stripe = await getStripeForAccount({ tenancy: auth.tenancy });
-            await stripe.subscriptions.cancel(subscription.stripeSubscriptionId);
-          }
-          await retryTransaction(prisma, async (tx) => {
-            if (!subscription.stripeSubscriptionId && subscription.id) {
-              await tx.subscription.update({
-                where: {
-                  tenancyId_id: {
-                    tenancyId: auth.tenancy.id,
-                    id: subscription.id,
-                  },
-                },
-                data: {
-                  status: SubscriptionStatus.canceled,
-                },
-              });
-            }
-            await tx.subscription.create({
-              data: {
+    if (!selectedPrice) {
+      throw new StackAssertionError("Price not resolved for test mode purchase session");
+    }
+
+    if (!selectedPrice.interval) {
+      await prisma.oneTimePurchase.create({
+        data: {
+          tenancyId: auth.tenancy.id,
+          customerId: data.customerId,
+          customerType: typedToUppercase(data.offer.customerType),
+          offerId: data.offerId,
+          offer: data.offer,
+          quantity,
+          creationSource: "TEST_MODE",
+        },
+      });
+    } else {
+      // Cancel conflicting subscriptions for TEST_MODE as well, then create new TEST_MODE subscription
+      if (conflictingGroupSubscriptions.length > 0) {
+        const conflicting = conflictingGroupSubscriptions[0];
+        if (conflicting.stripeSubscriptionId) {
+          const stripe = await getStripeForAccount({ tenancy: auth.tenancy });
+          await stripe.subscriptions.cancel(conflicting.stripeSubscriptionId);
+        } else if (conflicting.id) {
+          await prisma.subscription.update({
+            where: {
+              tenancyId_id: {
                 tenancyId: auth.tenancy.id,
-                customerId: data.customerId,
-                customerType: typedToUppercase(data.offer.customerType),
-                status: SubscriptionStatus.active,
-                offerId: data.offerId,
-                offer: data.offer,
-                quantity,
-                currentPeriodStart: new Date(),
-                currentPeriodEnd: addInterval(new Date(), selectedPrice.interval!),
-                cancelAtPeriodEnd: false,
-                creationSource: SubscriptionCreationSource.TEST_MODE,
+                id: conflicting.id,
               },
-            });
+            },
+            data: { status: SubscriptionStatus.canceled },
           });
         }
       }
-    }
 
-    if (selectedPrice?.interval) {
       await prisma.subscription.create({
         data: {
           tenancyId: auth.tenancy.id,
@@ -106,9 +90,9 @@ export const POST = createSmartRouteHandler({
           offer: data.offer,
           quantity,
           currentPeriodStart: new Date(),
-          currentPeriodEnd: addInterval(new Date(), selectedPrice.interval),
+          currentPeriodEnd: addInterval(new Date(), selectedPrice.interval!),
           cancelAtPeriodEnd: false,
-          creationSource: SubscriptionCreationSource.TEST_MODE,
+          creationSource: "TEST_MODE",
         },
       });
     }