refactor(stripe): Use PaymentIntent and subscriptions instead of Checkout sessions

apps/api/src/app/app.module.ts

@@ -11,7 +11,7 @@
 import { AppController } from './app.controller'
 import { CustomAuthGuard } from './custom-auth.guard'
 import configuration from '../config/configuration'
 import { PrismaService } from '../prisma/prisma.service'
 import { AccountModule } from '../account/account.module'
 import { HealthModule } from '../health/health.module'
 import { SupportModule } from '../support/support.module'
@@ -59,14 +59,19 @@
 
 import { StatisticsModule } from '../statistics/statistics.module'
 import { AffiliateModule } from '../affiliate/affiliate.module'
+import { StripeModule } from '../stripe/stripe.module'
 
 import { LoggerModule } from '../logger/logger.module'
 import { PrismaModule } from '../prisma/prisma.module'
 import { CampaignApplicationModule } from '../campaign-application/campaign-application.module'
 
 @Module({
   imports: [
-    ConfigModule.forRoot({ validationSchema, isGlobal: true, load: [configuration] }),
+    ConfigModule.forRoot({
+      validationSchema,
+      isGlobal: true,
+      load: [configuration],
+    }),
     /* External modules */
     SentryModule.forRootAsync({
       imports: [ConfigModule],
@@ -117,7 +122,7 @@
     BankTransactionsModule,
     StatisticsModule,
     CacheModule.registerAsync({
-      imports: [ConfigModule],
+      imports: [ConfigModule, AppModule],
       useFactory: async (config: ConfigService) => ({
         ttl: Number(config.get<number>('CACHE_TTL', 30 * 1000 /* ms */)),
       }),
@@ -129,6 +134,7 @@
     MarketingNotificationsModule,
     LoggerModule,
     CampaignApplicationModule,
+    StripeModule,
   ],
   controllers: [AppController],
   providers: [

apps/api/src/campaign/campaign.module.ts

@@ -12,16 +12,10 @@ import { CampaignNewsModule } from '../campaign-news/campaign-news.module'
 import { MarketingNotificationsModule } from '../notifications/notifications.module'
 import { PrismaModule } from '../prisma/prisma.module'
 @Module({
-  imports: [
-    forwardRef(() => VaultModule),
-    MarketingNotificationsModule,
-    NotificationModule,
-    CampaignNewsModule,
-    PrismaModule,
-  ],
+  imports: [MarketingNotificationsModule, NotificationModule, CampaignNewsModule],
 
   controllers: [CampaignController, CampaignTypeController],
-  providers: [CampaignService, VaultService, PersonService, ConfigService],
+  providers: [CampaignService, PrismaService, PersonService, ConfigService],
 
   exports: [CampaignService],
 })

apps/api/src/campaign/campaign.service.ts

@@ -56,8 +56,6 @@ import type { PaymentWithDonation } from '../donations/types/donation'
 export class CampaignService {
   constructor(
     private prisma: PrismaService,
-    private notificationService: NotificationService,
-    @Inject(forwardRef(() => VaultService)) private vaultService: VaultService,
     @Inject(forwardRef(() => PersonService)) private personService: PersonService,
     @Inject(forwardRef(() => MarketingNotificationsService))
     private marketingNotificationsService: MarketingNotificationsService,
@@ -578,225 +576,6 @@ export class CampaignService {
     return this.prisma.payment.findFirst({ where: { extPaymentIntentId: paymentIntentId } })
   }
 
-  /**
-   * Creates or Updates an incoming donation depending on the newDonationStatus attribute
-   * @param campaign
-   * @param paymentData
-   * @param newDonationStatus
-   * @param metadata
-   * @returns donation.id of the created/updated donation
-   */
-  async updateDonationPayment(
-    campaign: Campaign,
-    paymentData: PaymentData,
-    newDonationStatus: PaymentStatus,
-  ): Promise<string | undefined> {
-    const campaignId = campaign.id
-    Logger.debug('Update donation to status: ' + newDonationStatus, {
-      campaignId,
-      paymentIntentId: paymentData.paymentIntentId,
-    })
-
-    //Update existing donation or create new in a transaction that
-    //also increments the vault amount and marks campaign as completed
-    //if target amount is reached
-    return await this.prisma.$transaction(async (tx) => {
-      let donationId
-      // Find donation by extPaymentIntentId
-      const existingPayment = await this.findExistingDonation(tx, paymentData)
-
-      //if missing create the donation with the incoming status
-      if (!existingPayment) {
-        const newDonation = await this.createIncomingDonation(
-          tx,
-          paymentData,
-          newDonationStatus,
-          campaign,
-        )
-        donationId = newDonation.donations[0].id
-      }
-      //donation exists, so check if it is safe to update it
-      else {
-        const updatedDonation = await this.updateDonationIfAllowed(
-          tx,
-          existingPayment,
-          newDonationStatus,
-          paymentData,
-        )
-        donationId = updatedDonation?.donations[0].id
-      }
-      return donationId
-    }) //end of the transaction scope
-  }
-
-  private async updateDonationIfAllowed(
-    tx: Prisma.TransactionClient,
-    payment: PaymentWithDonation,
-    newDonationStatus: PaymentStatus,
-    paymentData: PaymentData,
-  ) {
-    if (shouldAllowStatusChange(payment.status, newDonationStatus)) {
-      try {
-        const updatedDonation = await tx.payment.update({
-          where: {
-            id: payment.id,
-          },
-          data: {
-            status: newDonationStatus,
-            amount: paymentData.netAmount,
-            extCustomerId: paymentData.stripeCustomerId,
-            extPaymentMethodId: paymentData.paymentMethodId,
-            extPaymentIntentId: paymentData.paymentIntentId,
-            billingName: paymentData.billingName,
-            billingEmail: paymentData.billingEmail,
-            donations: {
-              updateMany: {
-                where: { paymentId: payment.id },
-                data: {
-                  amount: paymentData.netAmount,
-                },
-              },
-            },
-          },
-          select: donationNotificationSelect,
-        })
-
-        //if donation is switching to successful, increment the vault amount and send notification
-        if (
-          payment.status != PaymentStatus.succeeded &&
-          newDonationStatus === PaymentStatus.succeeded
-        ) {
-          await this.vaultService.incrementVaultAmount(
-            payment.donations[0].targetVaultId,
-            paymentData.netAmount,
-            tx,
-          )
-          this.notificationService.sendNotification('successfulDonation', {
-            ...updatedDonation,
-            person: updatedDonation.donations[0].person,
-          })
-        } else if (
-          payment.status === PaymentStatus.succeeded &&
-          newDonationStatus === PaymentStatus.refund
-        ) {
-          await this.vaultService.decrementVaultAmount(
-            payment.donations[0].targetVaultId,
-            paymentData.netAmount,
-            tx,
-          )
-          this.notificationService.sendNotification('successfulRefund', {
-            ...updatedDonation,
-            person: updatedDonation.donations[0].person,
-          })
-        }
-        return updatedDonation
-      } catch (error) {
-        Logger.error(
-          `Error wile updating donation with paymentIntentId: ${paymentData.paymentIntentId} in database. Error is: ${error}`,
-        )
-        throw new InternalServerErrorException(error)
-      }
-    }
-    //donation exists but we need to skip because previous status is from later event than the incoming
-    else {
-      Logger.warn(
-        `Skipping update of donation with paymentIntentId: ${paymentData.paymentIntentId}
-        and status: ${newDonationStatus} because the event comes after existing donation with status: ${payment.status}`,
-      )
-    }
-  }
-
-  private async createIncomingDonation(
-    tx: Prisma.TransactionClient,
-    paymentData: PaymentData,
-    newDonationStatus: PaymentStatus,
-    campaign: Campaign,
-  ) {
-    Logger.debug(
-      'No donation exists with extPaymentIntentId: ' +
-        paymentData.paymentIntentId +
-        ' Creating new donation with status: ' +
-        newDonationStatus,
-    )
-
-    const vault = await tx.vault.findFirstOrThrow({ where: { campaignId: campaign.id } })
-    const targetVaultData = { connect: { id: vault.id } }
-
-    try {
-      const donation = await tx.payment.create({
-        data: {
-          amount: paymentData.netAmount,
-          chargedAmount: paymentData.chargedAmount,
-          currency: campaign.currency,
-          provider: paymentData.paymentProvider,
-          type: PaymentType.single,
-          status: newDonationStatus,
-          extCustomerId: paymentData.stripeCustomerId ?? '',
-          extPaymentIntentId: paymentData.paymentIntentId,
-          extPaymentMethodId: paymentData.paymentMethodId ?? '',
-          billingName: paymentData.billingName,
-          billingEmail: paymentData.billingEmail,
-          donations: {
-            create: {
-              amount: paymentData.netAmount,
-              type: paymentData.type as DonationType,
-              person: paymentData.personId ? { connect: { email: paymentData.billingEmail } } : {},
-              targetVault: targetVaultData,
-            },
-          },
-        },
-        select: donationNotificationSelect,
-      })
-
-      if (newDonationStatus === PaymentStatus.succeeded) {
-        await this.vaultService.incrementVaultAmount(
-          donation.donations[0].targetVaultId,
-          donation.amount,
-          tx,
-        )
-        this.notificationService.sendNotification('successfulDonation', donation)
-      }
-
-      return donation
-    } catch (error) {
-      Logger.error(
-        `Error while creating donation with paymentIntentId: ${paymentData.paymentIntentId} and status: ${newDonationStatus} . Error is: ${error}`,
-      )
-      throw new InternalServerErrorException(error)
-    }
-  }
-
-  private async findExistingDonation(tx: Prisma.TransactionClient, paymentData: PaymentData) {
-    //first try to find by paymentIntentId
-    let donation = await tx.payment.findUnique({
-      where: { extPaymentIntentId: paymentData.paymentIntentId },
-      include: { donations: true },
-    })
-
-    // if not found by paymentIntent, check for if this is payment on subscription
-    // check for UUID length of personId
-    // subscriptions always have a personId
-    if (!donation && paymentData.personId && paymentData.personId.length === 36) {
-      // search for a subscription donation
-      // for subscriptions, we don't have a paymentIntentId
-      donation = await tx.payment.findFirst({
-        where: {
-          status: PaymentStatus.initial,
-          chargedAmount: paymentData.chargedAmount,
-          extPaymentMethodId: 'subscription',
-          donations: {
-            some: {
-              personId: paymentData.personId,
-            },
-          },
-        },
-        include: { donations: true },
-      })
-      Logger.debug('Donation found by subscription: ', donation)
-    }
-    return donation
-  }
-
   async createDonationWish(wish: string, donationId: string, campaignId: string) {
     const person = await this.prisma.donation.findUnique({ where: { id: donationId } }).person()
     await this.prisma.donationWish.upsert({

apps/api/src/config/validation.config.ts

@@ -12,7 +12,7 @@ const globalValidationPipe = new ValidationPipe({
     exposeDefaultValues: true,
   },
   stopAtFirstError: false,
-  forbidUnknownValues: true,
+  forbidUnknownValues: false,
   disableErrorMessages: false,
   exceptionFactory: (errors) => new BadRequestException(errors),
   validationError: { target: false, value: false },