refactor: create new payment service and remove stripe service

Author: marcelodosreis

src/hooks/useCheckout.ts

@@ -4,7 +4,7 @@ import { HAS_FREE_TRIAL } from "@/constants/HAS_FREE_TRIAL";
 import { useToast } from "@/hooks/useToast";
 import { supabase } from '@/libs/supabase/client';
 import AuthService from '@/services/auth';
-import StripeService from '@/services/stripe';
+import PaymentService from '@/services/payment';
 
 export const useCheckout = () => {
     const { addToast } = useToast();
@@ -35,7 +35,7 @@ export const useCheckout = () => {
             const sessionId = jsonResponse.id;
 
             if (sessionId) {
-                await StripeService.redirectToCheckout(sessionId);
+                await PaymentService.redirectToCheckout(sessionId);
             } else {
                 addToast({
                     id: Date.now().toString(),

src/pages/api/payments/create-billing-portal.ts

@@ -3,7 +3,7 @@ import { NextApiRequest, NextApiResponse } from 'next';
 import { stripe } from '@/libs/stripe';
 import { supabaseServerClient } from '@/libs/supabase/server';
 import AuthService from '@/services/auth';
-import StripeService from '@/services/stripe';
+import PaymentService from '@/services/payment';
 import SubscriptionService from '@/services/subscription';
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
@@ -22,7 +22,7 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
         const AuthServiceInstance = new AuthService(supabaseServerClient);
         const SubscriptionServiceInstance = new SubscriptionService(supabaseServerClient);
 
-        const StripeServiceInstance = new StripeService(stripe);
+        const PaymentServiceInstance = new PaymentService(stripe);
 
 
         const user = await AuthServiceInstance.getUser(token);
@@ -37,13 +37,13 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
         if (!subscription) {
             return res.status(404).json({ error: 'No subscription found for user' });
         }
-        const customerId = await StripeServiceInstance.getCustomerIdFromSubscription(subscription.stripe_subscription_id);
+        const customerId = await PaymentServiceInstance.getCustomerIdFromSubscription(subscription.stripe_subscription_id);
 
         if (!customerId) {
             return res.status(404).json({ error: 'No customerId found for subscription' });
         }
 
-        const portalSession = await StripeServiceInstance.createBillingPortalSession(customerId);
+        const portalSession = await PaymentServiceInstance.createBillingPortalSession(customerId);
 
         return res.status(200).json({ url: portalSession.url });
     } catch (error) {

src/pages/api/payments/create-checkout.ts

@@ -1,7 +1,7 @@
 import { NextApiRequest, NextApiResponse } from 'next';
 
 import { stripe } from '@/libs/stripe';
-import StripeService from '@/services/stripe';
+import PaymentService from '@/services/payment';
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method !== 'POST') {
@@ -17,8 +17,8 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
   const freeTrial = hasFreeTrial ? Number(hasFreeTrial.split('d')?.[0]) : 0;
 
   try {
-    const stripeServiceInstance = new StripeService(stripe);
-    const session = await stripeServiceInstance.createCheckoutSession(
+    const PaymentServiceInstance = new PaymentService(stripe);
+    const session = await PaymentServiceInstance.createCheckoutSession(
       priceId,
       plan,
       userId,

src/pages/api/payments/get-plans.ts

@@ -2,7 +2,7 @@ import { NextApiRequest, NextApiResponse } from 'next';
 import Stripe from 'stripe';
 
 import { stripe } from '@/libs/stripe';
-import StripeService from '@/services/stripe';
+import PaymentService from '@/services/payment';
 import { loadTranslationsSSR } from '@/utils/loadTranslationsSSR';
 import { InputData, transformPurchasePlansDTO } from '@/utils/transformPurchasePlansDTO';
 
@@ -20,8 +20,8 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
 
 
     try {
-      const StripeServiceInstance = new StripeService(stripe);
-      const prices = await StripeServiceInstance.listActivePrices();
+      const PaymentServiceInstance = new PaymentService(stripe);
+      const prices = await PaymentServiceInstance.listActivePrices();
 
       const response = prices?.map((price) => {
         const product = price.product as Stripe.Product;

src/pages/api/webhooks.ts

@@ -5,7 +5,7 @@ import { stripe } from '@/libs/stripe';
 import { supabaseServerClient } from '@/libs/supabase/server';
 import AuthService from '@/services/auth';
 import EmailService from '@/services/email';
-import StripeService from '@/services/stripe';
+import PaymentService from '@/services/payment';
 import SubscriptionService from '@/services/subscription';
 
 const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET;
@@ -27,7 +27,7 @@ async function getRawBody(req: NextApiRequest): Promise<string> {
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method === 'POST') {
-    const StripeServiceInstance = new StripeService(stripe);
+    const PaymentServiceInstance = new PaymentService(stripe);
     const AuthServiceInstance = new AuthService(supabaseServerClient);
     const SubscriptionServiceInstance = new SubscriptionService(supabaseServerClient);
     const EmailServiceInstance = new EmailService();
@@ -44,7 +44,7 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     let event;
 
     try {
-      event = StripeServiceInstance.constructWebhookEvent(rawBody, sig, endpointSecret);
+      event = PaymentServiceInstance.constructWebhookEvent(rawBody, sig, endpointSecret);
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : 'Erro desconhecido';
       console.error('Erro ao verificar a assinatura do webhook:', errorMessage);

src/services/payment.ts

@@ -0,0 +1,125 @@
+import { loadStripe } from '@stripe/stripe-js';
+import Stripe from 'stripe';
+
+import { calculateCurrencyAmount } from '@/utils/calculateCurrencyAmount';
+
+export default class PaymentService {
+  private stripe: Stripe;
+
+  constructor(stripe: Stripe) {
+    this.stripe = stripe;
+  }
+
+  async createCheckoutSession(
+    priceId: string,
+    plan: string,
+    userId: string,
+    origin: string,
+    freeTrial?: number,
+    currency?: string
+  ): Promise<Stripe.Checkout.Session> {
+    const price = await this.getPrice(priceId);
+    const recurringInterval = price.recurring?.interval;
+
+    if (!recurringInterval) {
+      throw new Error('Recurring interval not found for this price');
+    }
+
+    const sessionData = this.buildCheckoutSessionData(
+      priceId,
+      plan,
+      userId,
+      origin,
+      recurringInterval,
+      freeTrial,
+      currency,
+      price.unit_amount
+    );
+
+    return await this.stripe.checkout.sessions.create(sessionData);
+  }
+
+  async listActivePrices(): Promise<Stripe.Price[]> {
+    const prices = await this.stripe.prices.list({ active: true, expand: ['data.product'] });
+    return prices.data;
+  }
+
+  constructWebhookEvent(rawBody: string | Buffer, sig: string | string[], secret: string): Stripe.Event {
+    return this.stripe.webhooks.constructEvent(rawBody, sig, secret);
+  }
+
+  async getCustomerIdFromSubscription(subscriptionId: string): Promise<string | null> {
+    try {
+      const subscription = await this.stripe.subscriptions.retrieve(subscriptionId);
+      return subscription.customer as string;
+    } catch (error) {
+      console.error('Erro ao buscar assinatura:', error);
+      return null;
+    }
+  }
+
+  async createBillingPortalSession(customerId: string): Promise<Stripe.BillingPortal.Session> {
+    return await this.stripe.billingPortal.sessions.create({
+      customer: customerId,
+      return_url: `${process.env.NEXT_PUBLIC_PROJECT_URL}/dashboard/subscription`,
+    });
+  }
+
+  static redirectToCheckout(sessionId: string): void {
+    loadStripe(process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY!).then((clientStripe) => {
+      clientStripe?.redirectToCheckout({ sessionId });
+    });
+  }
+
+  private async getPrice(priceId: string): Promise<Stripe.Price> {
+    return this.stripe.prices.retrieve(priceId);
+  }
+
+  private buildCheckoutSessionData(
+    priceId: string,
+    plan: string,
+    userId: string,
+    origin: string,
+    recurringInterval: Stripe.Price.Recurring.Interval,
+    freeTrial?: number,
+    currency?: string,
+    unitAmount?: number | null
+  ): Stripe.Checkout.SessionCreateParams {
+    const sessionData: Stripe.Checkout.SessionCreateParams = {
+      payment_method_types: ['card'],
+      line_items: [this.buildLineItem(priceId, plan, recurringInterval, currency, unitAmount)],
+      mode: 'subscription',
+      success_url: `${origin}/payments?status=success`,
+      cancel_url: `${origin}/payments?status=cancel`,
+      metadata: { userId, plan },
+    };
+
+    if (freeTrial) {
+      sessionData.subscription_data = { trial_period_days: freeTrial };
+    }
+
+    return sessionData;
+  }
+
+  private buildLineItem(
+    priceId: string,
+    plan: string,
+    recurringInterval: Stripe.Price.Recurring.Interval,
+    currency?: string,
+    unitAmount?: number | null
+  ): Stripe.Checkout.SessionCreateParams.LineItem {
+    if (!currency || !unitAmount) {
+      return { price: priceId, quantity: 1 };
+    }
+
+    return {
+      price_data: {
+        currency,
+        product_data: { name: plan },
+        recurring: { interval: recurringInterval },
+        unit_amount: calculateCurrencyAmount(String(unitAmount), currency),
+      },
+      quantity: 1,
+    };
+  }
+}