fix: price difference calc

Author: krakenhavoc

backend/src/billing/billing.service.spec.ts

@@ -11,7 +11,9 @@ const mockStripe = {
   checkout: { sessions: { create: jest.fn() } },
   billingPortal: { sessions: { create: jest.fn() } },
   subscriptions: { retrieve: jest.fn(), update: jest.fn() },
-  invoices: { createPreview: jest.fn() },
+  prices: { retrieve: jest.fn() },
+  invoiceItems: { create: jest.fn() },
+  invoices: { create: jest.fn(), pay: jest.fn() },
   webhooks: { constructEvent: jest.fn() },
 };
 jest.mock('stripe', () => {
@@ -360,50 +362,21 @@ describe('BillingService', () => {
 
     it('returns preview for valid upgrade', async () => {
       mockRepository.findOne.mockResolvedValue(mockSubscription);
-      mockStripe.subscriptions.retrieve.mockResolvedValue({
-        items: { data: [{ id: 'si_item1' }] },
-      });
-      mockStripe.invoices.createPreview.mockResolvedValue({
-        amount_due: 12900,
-        currency: 'usd',
-        lines: {
-          data: [
-            {
-              amount: -1935,
-              parent: {
-                subscription_item_details: { proration: true },
-              },
-            },
-            {
-              amount: 5270,
-              parent: {
-                subscription_item_details: { proration: true },
-              },
-            },
-            {
-              amount: 7900,
-              parent: {
-                subscription_item_details: { proration: false },
-              },
-            },
-          ],
-        },
-      });
+      mockStripe.prices.retrieve
+        .mockResolvedValueOnce({ unit_amount: 2900, currency: 'usd' })
+        .mockResolvedValueOnce({ unit_amount: 7900, currency: 'usd' });
 
       const result = await service.previewUpgrade(userId, 'team');
       expect(result).toEqual({
-        immediateAmountCents: 3335,
+        immediateAmountCents: 5000,
         currency: 'usd',
         targetPlan: 'team',
         currentPeriodEnd: mockSubscription.currentPeriodEnd!.toISOString(),
       });
-      expect(mockStripe.invoices.createPreview).toHaveBeenCalledWith({
-        subscription: 'sub_test123',
-        subscription_details: {
-          items: [{ id: 'si_item1', price: 'price_team_456' }],
-          proration_behavior: 'create_prorations',
-        },
-      });
+      expect(mockStripe.prices.retrieve).toHaveBeenCalledWith(
+        'price_starter_123',
+      );
+      expect(mockStripe.prices.retrieve).toHaveBeenCalledWith('price_team_456');
     });
   });
 
@@ -422,12 +395,18 @@ describe('BillingService', () => {
       ).rejects.toThrow(BadRequestException);
     });
 
-    it('upgrades subscription with proration', async () => {
+    it('upgrades subscription with flat difference', async () => {
       mockRepository.findOne.mockResolvedValue({ ...mockSubscription });
+      mockStripe.prices.retrieve
+        .mockResolvedValueOnce({ unit_amount: 2900, currency: 'usd' })
+        .mockResolvedValueOnce({ unit_amount: 7900, currency: 'usd' });
       mockStripe.subscriptions.retrieve.mockResolvedValue({
         items: { data: [{ id: 'si_item1' }] },
       });
       mockStripe.subscriptions.update.mockResolvedValue({});
+      mockStripe.invoiceItems.create.mockResolvedValue({});
+      mockStripe.invoices.create.mockResolvedValue({ id: 'inv_123' });
+      mockStripe.invoices.pay.mockResolvedValue({});
       mockRepository.save.mockResolvedValue({
         ...mockSubscription,
         plan: 'team',
@@ -439,9 +418,20 @@ describe('BillingService', () => {
         'sub_test123',
         {
           items: [{ id: 'si_item1', price: 'price_team_456' }],
-          proration_behavior: 'create_prorations',
+          proration_behavior: 'none',
         },
       );
+      expect(mockStripe.invoiceItems.create).toHaveBeenCalledWith({
+        customer: 'cus_test123',
+        amount: 5000,
+        currency: 'usd',
+        description: 'Plan upgrade: starter → team',
+      });
+      expect(mockStripe.invoices.create).toHaveBeenCalledWith({
+        customer: 'cus_test123',
+        auto_advance: true,
+      });
+      expect(mockStripe.invoices.pay).toHaveBeenCalledWith('inv_123');
       expect(mockRepository.save).toHaveBeenCalledWith(
         expect.objectContaining({ plan: 'team' }),
       );

backend/src/billing/billing.service.ts

@@ -142,38 +142,13 @@ export class BillingService {
     currentPeriodEnd: string;
   }> {
     const sub = await this.validateUpgrade(userId, newPlan);
-    const newPriceId = this.priceMap[newPlan];
-
-    const stripeSub = await this.stripe.subscriptions.retrieve(
-      sub.stripeSubscriptionId!,
-    );
-    const itemId = stripeSub.items.data[0].id;
 
-    const upcomingInvoice = await this.stripe.invoices.createPreview({
-      subscription: sub.stripeSubscriptionId!,
-      subscription_details: {
-        items: [{ id: itemId, price: newPriceId }],
-        proration_behavior: 'create_prorations',
-      },
-    });
-
-    // Sum only the proration line items — amount_due includes the next
-    // full billing cycle which isn't charged immediately.
-    const isProration = (line: Stripe.InvoiceLineItem): boolean => {
-      const parent = line.parent;
-      if (!parent) return false;
-      return (
-        parent.invoice_item_details?.proration === true ||
-        parent.subscription_item_details?.proration === true
-      );
-    };
-    const prorationAmount = upcomingInvoice.lines.data
-      .filter(isProration)
-      .reduce((sum, line) => sum + line.amount, 0);
+    const { currentPriceCents, newPriceCents, currency } =
+      await this.getPriceDifference(sub.plan, newPlan);
 
     return {
-      immediateAmountCents: prorationAmount,
-      currency: upcomingInvoice.currency,
+      immediateAmountCents: newPriceCents - currentPriceCents,
+      currency,
       targetPlan: newPlan,
       currentPeriodEnd: sub.currentPeriodEnd!.toISOString(),
     };
@@ -191,16 +166,35 @@ export class BillingService {
     const sub = await this.validateUpgrade(userId, newPlan);
     const newPriceId = this.priceMap[newPlan];
 
+    const { currentPriceCents, newPriceCents, currency } =
+      await this.getPriceDifference(sub.plan, newPlan);
+    const differenceCents = newPriceCents - currentPriceCents;
+
     const stripeSub = await this.stripe.subscriptions.retrieve(
       sub.stripeSubscriptionId!,
     );
     const itemId = stripeSub.items.data[0].id;
 
+    // Switch the plan without Stripe's day-based proration.
     await this.stripe.subscriptions.update(sub.stripeSubscriptionId!, {
       items: [{ id: itemId, price: newPriceId }],
-      proration_behavior: 'create_prorations',
+      proration_behavior: 'none',
+    });
+
+    // Charge the flat price difference immediately.
+    await this.stripe.invoiceItems.create({
+      customer: sub.stripeCustomerId,
+      amount: differenceCents,
+      currency,
+      description: `Plan upgrade: ${sub.plan} → ${newPlan}`,
     });
 
+    const invoice = await this.stripe.invoices.create({
+      customer: sub.stripeCustomerId,
+      auto_advance: true,
+    });
+    await this.stripe.invoices.pay(invoice.id);
+
     sub.plan = newPlan;
     await this.subscriptionRepository.save(sub);
 
@@ -214,6 +208,29 @@ export class BillingService {
     };
   }
 
+  private async getPriceDifference(
+    currentPlan: string,
+    newPlan: string,
+  ): Promise<{
+    currentPriceCents: number;
+    newPriceCents: number;
+    currency: string;
+  }> {
+    const currentPriceId = this.priceMap[currentPlan];
+    const newPriceId = this.priceMap[newPlan];
+
+    const [currentPrice, newPrice] = await Promise.all([
+      this.stripe.prices.retrieve(currentPriceId),
+      this.stripe.prices.retrieve(newPriceId),
+    ]);
+
+    return {
+      currentPriceCents: currentPrice.unit_amount ?? 0,
+      newPriceCents: newPrice.unit_amount ?? 0,
+      currency: newPrice.currency,
+    };
+  }
+
   private async validateUpgrade(
     userId: string,
     newPlan: string,