feat: Stripe payment integration

packages/server/src/api/controllers/PaymentServices/PaymentServicesController.ts

@@ -1,5 +1,6 @@
 import { Service, Inject } from 'typedi';
 import { Request, Response, Router, NextFunction } from 'express';
+import { body, param } from 'express-validator';
 import asyncMiddleware from '@/api/middleware/asyncMiddleware';
 import BaseController from '@/api/controllers/BaseController';
 import { PaymentServicesApplication } from '@/services/PaymentServices/PaymentServicesApplication';
@@ -19,6 +20,25 @@ export class PaymentServicesController extends BaseController {
       '/',
       asyncMiddleware(this.getPaymentServicesSpecificInvoice.bind(this))
     );
+    router.get('/state', this.getPaymentMethodsState.bind(this));
+    router.post(
+      '/:paymentMethodId',
+      [
+        param('paymentMethodId').exists(),
+        body('name').optional().isString(),
+        body('options.bankAccountId').optional().isNumeric(),
+        body('options.clearningAccountId').optional().isNumeric(),
+        body('options.showVisa').optional().isBoolean(),
+        body('options.showMasterCard').optional().isBoolean(),
+        body('options.showDiscover').optional().isBoolean(),
+        body('options.showAmer').optional().isBoolean(),
+        body('options.showJcb').optional().isBoolean(),
+        body('options.showDiners').optional().isBoolean(),
+      ],
+      this.validationResult,
+      asyncMiddleware(this.updatePaymentMethod.bind(this))
+    );
+
     return router;
   }
 
@@ -26,7 +46,7 @@ export class PaymentServicesController extends BaseController {
    * Retrieve accounts types list.
    * @param {Request} req - Request.
    * @param {Response} res - Response.
-   * @return {Response}
+   * @return {Promise<Response | void>}
    */
   private async getPaymentServicesSpecificInvoice(
     req: Request<{ invoiceId: number }>,
@@ -44,4 +64,58 @@ export class PaymentServicesController extends BaseController {
       next(error);
     }
   }
+
+  /**
+   * Edits the given payment method settings.
+   * @param {Request} req - Request.
+   * @param {Response} res - Response.
+   * @return {Promise<Response | void>}
+   */
+  private async updatePaymentMethod(
+    req: Request<{ paymentMethodId: number }>,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+    const { paymentMethodId } = req.params;
+    const updatePaymentMethodDTO = this.matchedBodyData(req);
+
+    try {
+      await this.paymentServicesApp.editPaymentMethod(
+        tenantId,
+        paymentMethodId,
+        updatePaymentMethodDTO
+      );
+      return res.status(200).send({
+        id: paymentMethodId,
+        message: 'The given payment method has been updated.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Retrieves the payment state providing state.
+   * @param {Request} req - Request.
+   * @param {Response} res - Response.
+   * @param {NextFunction} next - Next function.
+   * @return {Promise<Response | void>}
+   */
+  private async getPaymentMethodsState(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) {
+    const { tenantId } = req;
+
+    try {
+      const paymentMethodsState =
+        await this.paymentServicesApp.getPaymentMethodsState(tenantId);
+
+      return res.status(200).send({ data: paymentMethodsState });
+    } catch (error) {
+      next(error);
+    }
+  }
 }

packages/server/src/api/controllers/StripeIntegration/StripeIntegrationController.ts

@@ -1,26 +1,29 @@
 import { NextFunction, Request, Response, Router } from 'express';
+import { body } from 'express-validator';
 import { Service, Inject } from 'typedi';
 import asyncMiddleware from '@/api/middleware/asyncMiddleware';
 import { StripePaymentApplication } from '@/services/StripePayment/StripePaymentApplication';
+import BaseController from '../BaseController';
 
 @Service()
-export class StripeIntegrationController {
+export class StripeIntegrationController extends BaseController {
   @Inject()
   private stripePaymentApp: StripePaymentApplication;
 
-  router() {
+  public router() {
     const router = Router();
 
     router.post('/account', asyncMiddleware(this.createAccount.bind(this)));
     router.post(
-      '/account_session',
-      asyncMiddleware(this.createAccountSession.bind(this))
+      '/account_link',
+      [body('stripe_account_id').exists()],
+      this.validationResult,
+      asyncMiddleware(this.createAccountLink.bind(this))
     );
     router.post(
       '/:linkId/create_checkout_session',
       this.createCheckoutSession.bind(this)
     );
-
     return router;
   }
 
@@ -65,8 +68,7 @@ export class StripeIntegrationController {
       const accountId = await this.stripePaymentApp.createStripeAccount(
         tenantId
       );
-
-      res.status(201).json({
+      return res.status(201).json({
         accountId,
         message: 'The Stripe account has been created successfully.',
       });
@@ -82,20 +84,20 @@ export class StripeIntegrationController {
    * @param {NextFunction} next - The Express next middleware function.
    * @returns {Promise<void>}
    */
-  public async createAccountSession(
+  public async createAccountLink(
     req: Request,
     res: Response,
     next: NextFunction
   ) {
     const { tenantId } = req;
-    const { account } = req.body;
+    const { stripeAccountId } = this.matchedBodyData(req);
 
     try {
-      const clientSecret = await this.stripePaymentApp.createStripeAccount(
+      const clientSecret = await this.stripePaymentApp.createAccountLink(
         tenantId,
-        account
+        stripeAccountId
       );
-      res.status(200).json({ clientSecret });
+      return res.status(200).json({ clientSecret });
     } catch (error) {
       next(error);
     }

packages/server/src/api/controllers/StripeIntegration/StripeWebhooksController.ts

@@ -15,7 +15,7 @@ export class StripeWebhooksController {
   @Inject()
   private eventPublisher: EventPublisher;
 
-  router() {
+  public router() {
     const router = Router();
 
     router.post(
@@ -35,7 +35,7 @@ export class StripeWebhooksController {
    * @param {Response} res - The Express response object.
    * @param {NextFunction} next - The Express next middleware function.
    */
-  public async handleWebhook(req: Request, res: Response, next: NextFunction) {
+  private async handleWebhook(req: Request, res: Response, next: NextFunction) {
     try {
       let event = req.body;
       const sig = req.headers['stripe-signature'];

packages/server/src/database/migrations/20240915155403_payment_integration.js

@@ -8,7 +8,7 @@ exports.up = function (knex) {
     table.string('service');
     table.string('name'); 
     table.string('slug');
-    table.boolean('enable').defaultTo(true);
+    table.boolean('active').defaultTo(false);
     table.string('account_id');
     table.json('options');
     table.timestamps();

packages/server/src/interfaces/StripePayment.ts

@@ -9,9 +9,8 @@ export interface StripeCheckoutSessionCompletedEventPayload {
   event: any;
 }
 
-
 export interface StripeInvoiceCheckoutSessionPOJO {
   sessionId: string;
   publishableKey: string;
   redirectTo: string;
-}
+}

packages/server/src/services/PaymentServices/DeletePaymentMethodService.ts

@@ -0,0 +1,54 @@
+import { Inject, Service } from 'typedi';
+import { Knex } from 'knex';
+import HasTenancyService from '../Tenancy/TenancyService';
+import UnitOfWork from '../UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+
+@Service()
+export class DeletePaymentMethodService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Deletes the given payment integration.
+   * @param {number} tenantId
+   * @param {number} paymentIntegrationId
+   * @returns {Promise<void>}
+   */
+  public async deletePaymentMethod(
+    tenantId: number,
+    paymentIntegrationId: number
+  ): Promise<void> {
+    const { PaymentIntegration, TransactionPaymentServiceEntry } =
+      this.tenancy.models(tenantId);
+
+    const paymentIntegration = await PaymentIntegration.query()
+      .findById(paymentIntegrationId)
+      .throwIfNotFound();
+
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Delete payment methods links.
+      await TransactionPaymentServiceEntry.query(trx)
+        .where('paymentIntegrationId', paymentIntegrationId)
+        .delete();
+
+      // Delete the payment integration.
+      await PaymentIntegration.query(trx)
+        .findById(paymentIntegrationId)
+        .delete();
+
+      // Triggers `onPaymentMethodDeleted` event.
+      await this.eventPublisher.emitAsync(events.paymentMethod.onDeleted, {
+        tenantId,
+        paymentIntegrationId,
+      });
+    });
+  }
+}

packages/server/src/services/PaymentServices/EditPaymentMethodService.ts

@@ -0,0 +1,60 @@
+import { Knex } from 'knex';
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '../Tenancy/TenancyService';
+import UnitOfWork from '../UnitOfWork';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import { EditPaymentMethodDTO } from './types';
+import events from '@/subscribers/events';
+
+@Service()
+export class EditPaymentMethodService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Edits the given payment method.
+   * @param {number} tenantId
+   * @param {number} paymentIntegrationId
+   * @param {EditPaymentMethodDTO} editPaymentMethodDTO
+   * @returns {Promise<void>}
+   */
+  async editPaymentMethod(
+    tenantId: number,
+    paymentIntegrationId: number,
+    editPaymentMethodDTO: EditPaymentMethodDTO
+  ): Promise<void> {
+    const { PaymentIntegration } = this.tenancy.models(tenantId);
+
+    const paymentMethod = await PaymentIntegration.query()
+      .findById(paymentIntegrationId)
+      .throwIfNotFound();
+
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onPaymentMethodEditing` event.
+      await this.eventPublisher.emitAsync(events.paymentMethod.onEditing, {
+        tenantId,
+        paymentIntegrationId,
+        editPaymentMethodDTO,
+        trx,
+      });
+      await PaymentIntegration.query(trx)
+        .findById(paymentIntegrationId)
+        .patch({
+          ...editPaymentMethodDTO,
+        });
+      // Triggers `onPaymentMethodEdited` event.
+      await this.eventPublisher.emitAsync(events.paymentMethod.onEdited, {
+        tenantId,
+        paymentIntegrationId,
+        editPaymentMethodDTO,
+        trx,
+      });
+    });
+  }
+}

packages/server/src/services/PaymentServices/GetPaymentMethodsState.ts

@@ -0,0 +1,46 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '../Tenancy/TenancyService';
+import { GetPaymentMethodsPOJO } from './types';
+import config from '@/config';
+
+@Service()
+export class GetPaymentMethodsStateService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Retrieves the payment state provising state.
+   * @param {number} tenantId
+   * @returns {Promise<GetPaymentMethodsPOJO>}
+   */
+  public async getPaymentMethodsState(
+    tenantId: number
+  ): Promise<GetPaymentMethodsPOJO> {
+    const { PaymentIntegration } = this.tenancy.models(tenantId);
+
+    const stripePayment = await PaymentIntegration.query()
+      .orderBy('createdAt', 'ASC')
+      .findOne({
+        service: 'Stripe',
+      });
+    const isStripeAccountCreated = !!stripePayment;
+    const isStripePaymentActive = !!(stripePayment?.active || null);
+
+    const stripeAccountId = stripePayment?.accountId || null;
+    const stripePublishableKey = config.stripePayment.publishableKey;
+    const stripeCurrencies = ['USD', 'EUR'];
+    const stripeRedirectUrl = 'https://your-stripe-redirect-url.com';
+
+    const paymentMethodPOJO: GetPaymentMethodsPOJO = {
+      stripe: {
+        isStripeAccountCreated,
+        isStripePaymentActive,
+        stripeAccountId,
+        stripePublishableKey,
+        stripeCurrencies,
+        stripeRedirectUrl,
+      },
+    };
+    return paymentMethodPOJO;
+  }
+}

packages/server/src/services/PaymentServices/PaymentServicesApplication.ts

@@ -1,20 +1,79 @@
 import { Service, Inject } from 'typedi';
 import { GetPaymentServicesSpecificInvoice } from './GetPaymentServicesSpecificInvoice';
+import { DeletePaymentMethodService } from './DeletePaymentMethodService';
+import { EditPaymentMethodService } from './EditPaymentMethodService';
+import { EditPaymentMethodDTO, GetPaymentMethodsPOJO } from './types';
+import { GetPaymentMethodsStateService } from './GetPaymentMethodsState';
 
 @Service()
 export class PaymentServicesApplication {
   @Inject()
   private getPaymentServicesSpecificInvoice: GetPaymentServicesSpecificInvoice;
 
+  @Inject()
+  private deletePaymentMethodService: DeletePaymentMethodService;
+
+  @Inject()
+  private editPaymentMethodService: EditPaymentMethodService;
+
+  @Inject()
+  private getPaymentMethodsStateService: GetPaymentMethodsStateService;
+
   /**
    * Retrieves the payment services for a specific invoice.
    * @param {number} tenantId - The ID of the tenant.
    * @param {number} invoiceId - The ID of the invoice.
    * @returns {Promise<any>} The payment services for the specified invoice.
    */
-  async getPaymentServicesForInvoice(tenantId: number): Promise<any> {
+  public async getPaymentServicesForInvoice(tenantId: number): Promise<any> {
     return this.getPaymentServicesSpecificInvoice.getPaymentServicesInvoice(
       tenantId
     );
   }
+
+  /**
+   * Deletes the given payment method.
+   * @param {number} tenantId
+   * @param {number} paymentIntegrationId
+   * @returns {Promise<void>}
+   */
+  public async deletePaymentMethod(
+    tenantId: number,
+    paymentIntegrationId: number
+  ): Promise<void> {
+    return this.deletePaymentMethodService.deletePaymentMethod(
+      tenantId,
+      paymentIntegrationId
+    );
+  }
+
+  /**
+   * Edits the given payment method.
+   * @param {number} tenantId
+   * @param {number} paymentIntegrationId
+   * @param {EditPaymentMethodDTO} editPaymentMethodDTO
+   * @returns {Promise<void>}
+   */
+  public async editPaymentMethod(
+    tenantId: number,
+    paymentIntegrationId: number,
+    editPaymentMethodDTO: EditPaymentMethodDTO
+  ): Promise<void> {
+    return this.editPaymentMethodService.editPaymentMethod(
+      tenantId,
+      paymentIntegrationId,
+      editPaymentMethodDTO
+    );
+  }
+
+  /**
+   * Retrieves the payment state providing state.
+   * @param {number} tenantId
+   * @returns {Promise<GetPaymentMethodsPOJO>}
+   */
+  public async getPaymentMethodsState(
+    tenantId: number
+  ): Promise<GetPaymentMethodsPOJO> {
+    return this.getPaymentMethodsStateService.getPaymentMethodsState(tenantId);
+  }
 }

packages/server/src/services/PaymentServices/types.ts

@@ -0,0 +1,25 @@
+export interface EditPaymentMethodDTO {
+  name?: string;
+  options?: {
+    bankAccountId?: number; // bank account.
+    clearningAccountId?: number; // current liability.
+
+    showVisa?: boolean;
+    showMasterCard?: boolean;
+    showDiscover?: boolean;
+    showAmer?: boolean;
+    showJcb?: boolean;
+    showDiners?: boolean;
+  };
+}
+
+export interface GetPaymentMethodsPOJO {
+  stripe: {
+    isStripeAccountCreated: boolean;
+    isStripePaymentActive: boolean;
+    stripeAccountId: string | null;
+    stripePublishableKey: string | null;
+    stripeCurrencies: Array<string>;
+    stripeRedirectUrl: string | null;
+  };
+}

packages/server/src/services/StripePayment/CreateStripeAccountLink.ts

@@ -0,0 +1,16 @@
+import { Service, Inject } from 'typedi';
+import { StripePaymentService } from './StripePaymentService';
+
+@Service()
+export class CreateStripeAccountLinkService {
+  @Inject()
+  private stripePaymentService: StripePaymentService;
+
+  /**
+   * Creates a new Stripe account id.
+   * @param {number} tenantId
+   */
+  public createAccountLink(tenantId: number, stripeAccountId: string) {
+    return this.stripePaymentService.createAccountLink(stripeAccountId);
+  }
+}

packages/server/src/services/StripePayment/CreateStripeAccountService.ts

@@ -38,7 +38,7 @@ export class CreateStripeAccountService {
     await PaymentIntegration.query().insert({
       name: parsedStripeAccountDTO.name,
       accountId: stripeAccountId,
-      enable: false,
+      active: false, // Active will turn true after onboarding.
       service: 'Stripe',
     });
     // Triggers `onStripeIntegrationAccountCreated` event.

packages/server/src/services/StripePayment/StripePaymentApplication.ts

@@ -2,12 +2,16 @@ import { Inject } from 'typedi';
 import { CreateInvoiceCheckoutSession } from './CreateInvoiceCheckoutSession';
 import { StripeInvoiceCheckoutSessionPOJO } from '@/interfaces/StripePayment';
 import { CreateStripeAccountService } from './CreateStripeAccountService';
+import { CreateStripeAccountLinkService } from './CreateStripeAccountLink';
 import { CreateStripeAccountDTO } from './types';
 
 export class StripePaymentApplication {
   @Inject()
   private createStripeAccountService: CreateStripeAccountService;
 
+  @Inject()
+  private createStripeAccountLinkService: CreateStripeAccountLinkService;
+
   @Inject()
   private createInvoiceCheckoutSessionService: CreateInvoiceCheckoutSession;
 
@@ -26,6 +30,19 @@ export class StripePaymentApplication {
     );
   }
 
+  /**
+   * Creates a new Stripe account link of the given Stripe accoun..
+   * @param {number} tenantId
+   * @param {string} stripeAccountId
+   * @returns {}
+   */
+  public createAccountLink(tenantId: number, stripeAccountId: string) {
+    return this.createStripeAccountLinkService.createAccountLink(
+      tenantId,
+      stripeAccountId
+    );
+  }
+
   /**
    * Creates the Stripe checkout session from the given sale invoice.
    * @param {number} tenantId

packages/server/src/services/StripePayment/StripePaymentService.ts

@@ -2,6 +2,8 @@ import { Service } from 'typedi';
 import stripe from 'stripe';
 import config from '@/config';
 
+const origin = 'http://localhost:4000';
+
 @Service()
 export class StripePaymentService {
   public stripe;
@@ -13,8 +15,8 @@ export class StripePaymentService {
   }
 
   /**
-   * 
-   * @param {number} accountId 
+   *
+   * @param {number} accountId
    * @returns {Promise<string>}
    */
   public async createAccountSession(accountId: string): Promise<string> {
@@ -35,6 +37,27 @@ export class StripePaymentService {
 
   /**
    * 
+   * @param {number} accountId 
+   * @returns 
+   */
+  public async createAccountLink(accountId: string) {
+    try {
+      const accountLink = await this.stripe.accountLinks.create({
+        account: accountId,
+        return_url: `${origin}/return/${accountId}`,
+        refresh_url: `${origin}/refresh/${accountId}`,
+        type: 'account_onboarding',
+      });
+      return accountLink;
+    } catch (error) {
+      throw new Error(
+        'An error occurred when calling the Stripe API to create an account link:'
+      );
+    }
+  }
+
+  /**
+   *
    * @returns {Promise<string>}
    */
   public async createAccount(): Promise<string> {

packages/server/src/subscribers/events.ts

@@ -703,6 +703,14 @@ export default {
     onAssigningDefault: 'onPdfTemplateAssigningDefault',
   },
 
+  // Payment method.
+  paymentMethod: {
+    onEditing: 'onPaymentMethodEditing',
+    onEdited: 'onPaymentMethodEdited',
+
+    onDeleted: 'onPaymentMethodDeleted',
+  },
+
   // Payment methods integrations
   paymentIntegrationLink: {
     onPaymentIntegrationLink: 'onPaymentIntegrationLink',