feat: add create checkout session usecase

Author: ImFelipeOliveira

src/application/usecases/subscription/create-checkout-session.usecase.ts

@@ -0,0 +1,51 @@
+import { IUseCase } from "../interfaces/usecase.interface";
+import { HttpStatus } from "@/infra/http/protocols.enum";
+import { DomainException } from "@/domain/error";
+import { IRepositoryFactory, IServiceFactory } from "@/application/factories";
+import { IUserRepository } from "@/application";
+import { IPaymentGatewayService } from "@/infra/services";
+
+export namespace CreateCheckoutSessionNamespace {
+  export interface Input {
+    userId: string;
+    priceId: string;
+  }
+
+  export interface Output {
+    sessionId: string;
+    successUrl: string | null;
+    cancelUrl: string | null;
+  }
+}
+
+export class CreateCheckoutSessionUseCase implements IUseCase {
+  private userRepository: IUserRepository;
+  private paymentGatewayService: IPaymentGatewayService;
+
+  constructor(
+    private repositoryFactory: IRepositoryFactory,
+    private serviceFactory: IServiceFactory,
+  ) {
+    this.userRepository = this.repositoryFactory.createUserRepository();
+    this.paymentGatewayService =
+      this.serviceFactory.createPaymentGatewayService();
+  }
+
+  async execute(
+    input: CreateCheckoutSessionNamespace.Input,
+  ): Promise<CreateCheckoutSessionNamespace.Output> {
+    const user = await this.userRepository.getById(input.userId);
+    if (!user) {
+      throw new DomainException("User not found", HttpStatus.NOT_FOUND);
+    }
+    const session = await this.paymentGatewayService.createCheckoutSession({
+      priceId: input.priceId,
+      userId: input.userId,
+    });
+    return {
+      sessionId: session.sessionId,
+      successUrl: session.successUrl,
+      cancelUrl: session.cancelUrl,
+    };
+  }
+}

src/config/env.ts

@@ -32,6 +32,8 @@ export const env = {
   },
   stripe: {
     stripe_secret: process.env.STRIPE_SECRET,
+    success_url: process.env.STRIPE_SUCCESS_URL,
+    cancel_url: process.env.STRIPE_CANCEL_URL,
     price_ids: {
       basic: process.env.STRIPE_PRICE_ID_BASIC,
       standard: process.env.STRIPE_PRICE_ID_STANDARD,

src/infra/adapters/payment-gateway/interfaces/payment-gateway.interface.ts

@@ -41,9 +41,18 @@ export namespace IPaymentGatewayOutput {
   export interface SaveCard {
     paymentMethod: string;
   }
+
+  export interface CheckoutSessionOutput {
+    sessionId: string;
+    url: string;
+  }
 }
 
 export interface IPaymentGateway {
+  createCheckoutSession(
+    priceId: string,
+    userID: string,
+  ): Promise<Stripe.Checkout.Session>;
   createCustomer(user: User): Promise<string>;
   charge(
     input: IPaymentGatewayInput.Charge,
@@ -64,4 +73,5 @@ export interface IPaymentGateway {
     customerId: string,
   ): Promise<Stripe.Customer | Stripe.DeletedCustomer>;
   retrieveSubscription(subscriptionId: string): Promise<Stripe.Subscription>;
+  retrievePaymentMethod(paymentMethodId: string): Promise<Stripe.PaymentMethod>;
 }

src/infra/adapters/payment-gateway/stripe-adapter.ts

@@ -16,6 +16,21 @@ export class StripeAdapter implements IPaymentGateway {
     this.stripe = new Stripe(env.stripe.stripe_secret!);
   }
 
+  async createCheckoutSession(
+    priceId: string,
+    userId: string,
+  ): Promise<Stripe.Checkout.Session> {
+    return await this.stripe.checkout.sessions.create({
+      mode: "subscription",
+      line_items: [{ price: priceId, quantity: 1 }],
+      success_url: `${env.stripe.success_url}?session_id={CHECKOUT_SESSION_ID}`,
+      cancel_url: env.stripe.cancel_url,
+      metadata: {
+        userId: userId,
+      },
+    });
+  }
+
   async createCustomer(user: User): Promise<string> {
     const customer = await this.stripe.customers.create({
       name: user.getName,
@@ -159,4 +174,10 @@ export class StripeAdapter implements IPaymentGateway {
   ): Promise<Stripe.Subscription> {
     return await this.stripe.subscriptions.retrieve(subscriptionId);
   }
+
+  async retrievePaymentMethod(
+    paymentMethodId: string,
+  ): Promise<Stripe.PaymentMethod> {
+    return await this.stripe.paymentMethods.retrieve(paymentMethodId);
+  }
 }

src/infra/services/payment-gateway/interfaces/payment-gateway-service.interface.ts

@@ -18,9 +18,19 @@ export namespace PaymentGatewayServiceInput {
     priceId: string;
     paymentMethodId: string;
   }
+
+  export interface CheckoutSessionOutput {
+    sessionId: string;
+    successUrl: string | null;
+    cancelUrl: string | null;
+  }
 }
 
 export interface IPaymentGatewayService {
+  createCheckoutSession(input: {
+    priceId: string;
+    userId: string;
+  }): Promise<PaymentGatewayServiceInput.CheckoutSessionOutput>;
   createSubscription(
     input: PaymentGatewayServiceInput.CreateSubscription,
     subscriptionId: string,

src/infra/services/payment-gateway/payment-gateway-service.ts

@@ -21,6 +21,21 @@ export class PaymentGatewayService implements IPaymentGatewayService {
       this.repositoryFactory.createSubscriptionStripeDataModelRepository();
   }
 
+  async createCheckoutSession(input: {
+    priceId: string;
+    userId: string;
+  }): Promise<PaymentGatewayServiceInput.CheckoutSessionOutput> {
+    const session = await this.stripeAdapter.createCheckoutSession(
+      input.priceId,
+      input.userId,
+    );
+    return {
+      sessionId: session.id,
+      successUrl: session.success_url,
+      cancelUrl: session.cancel_url,
+    };
+  }
+
   async createSubscription(
     input: PaymentGatewayServiceInput.CreateSubscription,
     subscriptionId: string,
@@ -90,8 +105,8 @@ export class PaymentGatewayService implements IPaymentGatewayService {
     savedCard: IPaymentGatewayOutput.SaveCard,
   ) {
     if (stripeData.stripePaymentMethodId !== savedCard.paymentMethod)
-      return savedCard.paymentMethod;
-    return stripeData.stripePaymentMethodId;
+      return stripeData.stripePaymentMethodId;
+    return savedCard.paymentMethod;
   }
 
   private buildToSave(input: {

src/tests/config/env.test.ts

@@ -22,6 +22,8 @@ describe("Environment Configuration", () => {
       expect(env.smtp.password).toBeDefined();
       expect(env.stripe).toBeDefined();
       expect(typeof env.stripe.stripe_secret).toBe("string");
+      expect(typeof env.stripe.success_url).toBe("string");
+      expect(typeof env.stripe.cancel_url).toBe("string");
       expect(typeof env.stripe.price_ids.basic).toBe("string");
       expect(typeof env.stripe.price_ids.standard).toBe("string");
       expect(typeof env.stripe.price_ids.premium).toBe("string");