@forklaunch/implementation-billing-stripe 0.0.1

package/lib/eject/services/webhook.service.ts

@@ -0,0 +1,272 @@
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector
+} from '@forklaunch/core/http';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import { BillingProviderEnum } from '../domain/enums/billingProvider.enum';
+import { CurrencyEnum } from '../domain/enums/currency.enum';
+import { PaymentMethodEnum } from '../domain/enums/paymentMethod.enum';
+import { PlanCadenceEnum } from '../domain/enums/planCadence.enum';
+import {
+  StripeBillingPortalEntities,
+  StripeCheckoutSessionEntities,
+  StripePaymentLinkEntities,
+  StripePlanEntities,
+  StripeSubscriptionEntities
+} from '../types/stripe.entity.types';
+import { StripeBillingPortalService } from './billingPortal.service';
+import { StripeCheckoutSessionService } from './checkoutSession.service';
+import { StripePaymentLinkService } from './paymentLink.service';
+import { StripePlanService } from './plan.service';
+import { StripeSubscriptionService } from './subscription.service';
+
+export class StripeWebhookService<
+  SchemaValidator extends AnySchemaValidator,
+  StatusEnum,
+  PartyEnum,
+  BillingPortalEntities extends
+    StripeBillingPortalEntities = StripeBillingPortalEntities,
+  CheckoutSessionEntities extends
+    StripeCheckoutSessionEntities<StatusEnum> = StripeCheckoutSessionEntities<StatusEnum>,
+  PaymentLinkEntities extends
+    StripePaymentLinkEntities<StatusEnum> = StripePaymentLinkEntities<StatusEnum>,
+  PlanEntities extends StripePlanEntities = StripePlanEntities,
+  SubscriptionEntities extends
+    StripeSubscriptionEntities<PartyEnum> = StripeSubscriptionEntities<PartyEnum>
+> {
+  constructor(
+    protected readonly stripeClient: Stripe,
+    protected readonly em: EntityManager,
+    protected readonly schemaValidator: SchemaValidator,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    protected readonly billingPortalService: StripeBillingPortalService<
+      SchemaValidator,
+      BillingPortalEntities
+    >,
+    protected readonly checkoutSessionService: StripeCheckoutSessionService<
+      SchemaValidator,
+      StatusEnum,
+      CheckoutSessionEntities
+    >,
+    protected readonly paymentLinkService: StripePaymentLinkService<
+      SchemaValidator,
+      StatusEnum,
+      PaymentLinkEntities
+    >,
+    protected readonly planService: StripePlanService<
+      SchemaValidator,
+      PlanEntities
+    >,
+    protected readonly subscriptionService: StripeSubscriptionService<
+      SchemaValidator,
+      PartyEnum,
+      SubscriptionEntities
+    >
+  ) {}
+
+  async handleWebhookEvent(event: Stripe.Event): Promise<void> {
+    if (this.openTelemetryCollector) {
+      this.openTelemetryCollector.info('Handling webhook event', event);
+    }
+    const eventType = event.type;
+
+    switch (eventType) {
+      case 'billing_portal.session.created': {
+        this.billingPortalService.baseBillingPortalService.createBillingPortalSession(
+          {
+            id: event.data.object.id,
+            customerId: event.data.object.customer,
+            expiresAt: new Date(event.data.object.created + 5 * 60 * 1000),
+            uri: event.data.object.url,
+            providerFields: event.data.object
+          }
+        );
+        break;
+      }
+
+      case 'checkout.session.expired': {
+        this.checkoutSessionService.handleCheckoutFailure({
+          id: event.data.object.id
+        });
+        break;
+      }
+
+      case 'checkout.session.completed': {
+        this.checkoutSessionService.handleCheckoutSuccess({
+          id: event.data.object.id
+        });
+        break;
+      }
+
+      case 'payment_link.created':
+        {
+          this.paymentLinkService.basePaymentLinkService.createPaymentLink({
+            id: event.data.object.id,
+            amount:
+              event.data.object.line_items?.data.reduce<number>(
+                (total, item) => total + item.amount_total,
+                0
+              ) ?? 0,
+            paymentMethods: event.data.object
+              .payment_method_types as PaymentMethodEnum[],
+            status: 'CREATED' as StatusEnum[keyof StatusEnum],
+            currency: event.data.object.currency as CurrencyEnum,
+            providerFields: event.data.object
+          });
+        }
+        break;
+
+      case 'payment_link.updated': {
+        this.paymentLinkService.basePaymentLinkService.updatePaymentLink({
+          id: event.data.object.id,
+          amount:
+            event.data.object.line_items?.data.reduce<number>(
+              (total, item) => total + item.amount_total,
+              0
+            ) ?? 0,
+          paymentMethods: event.data.object
+            .payment_method_types as PaymentMethodEnum[],
+          status: 'UPDATED' as StatusEnum[keyof StatusEnum],
+          currency: event.data.object.currency as CurrencyEnum,
+          providerFields: event.data.object
+        });
+        break;
+      }
+
+      case 'plan.created': {
+        if (
+          typeof event.data.object.product === 'object' &&
+          event.data.object.product != null &&
+          event.data.object.amount != null
+        ) {
+          this.planService.basePlanService.createPlan({
+            id: event.data.object.id,
+            billingProvider: BillingProviderEnum.STRIPE,
+            cadence: event.data.object.interval as PlanCadenceEnum,
+            currency: event.data.object.currency as CurrencyEnum,
+            active: true,
+            name:
+              typeof event.data.object.product === 'string'
+                ? event.data.object.product
+                : event.data.object.product?.id,
+            price: event.data.object.amount,
+            externalId: event.data.object.id,
+            providerFields: event.data.object
+          });
+        } else {
+          throw new Error('Invalid plan');
+        }
+        break;
+      }
+
+      case 'plan.updated': {
+        if (
+          typeof event.data.object.product === 'object' &&
+          event.data.object.product != null &&
+          event.data.object.amount != null
+        ) {
+          this.planService.basePlanService.updatePlan({
+            id: event.data.object.id,
+            billingProvider: BillingProviderEnum.STRIPE,
+            cadence: event.data.object.interval as PlanCadenceEnum,
+            currency: event.data.object.currency as CurrencyEnum,
+            active: true,
+            name:
+              typeof event.data.object.product === 'string'
+                ? event.data.object.product
+                : event.data.object.product?.id,
+            price: event.data.object.amount,
+            externalId: event.data.object.id,
+            providerFields: event.data.object
+          });
+        } else {
+          throw new Error('Invalid plan');
+        }
+        break;
+      }
+
+      case 'plan.deleted': {
+        this.planService.deletePlan({
+          id: event.data.object.id
+        });
+        break;
+      }
+
+      case 'customer.subscription.created': {
+        this.subscriptionService.baseSubscriptionService.createSubscription({
+          id: event.data.object.id,
+          partyId:
+            typeof event.data.object.customer === 'string'
+              ? event.data.object.customer
+              : event.data.object.customer.id,
+          partyType: 'USER' as PartyEnum[keyof PartyEnum],
+          description: event.data.object.description ?? undefined,
+          active: true,
+          productId: event.data.object.items.data[0].plan.id,
+          providerFields: event.data.object,
+          externalId: event.data.object.id,
+          billingProvider: BillingProviderEnum.STRIPE,
+          startDate: new Date(event.data.object.created),
+          endDate: event.data.object.cancel_at
+            ? new Date(event.data.object.cancel_at)
+            : new Date(Infinity),
+          status: event.data.object.status
+        });
+        break;
+      }
+
+      case 'customer.subscription.updated': {
+        this.subscriptionService.baseSubscriptionService.updateSubscription({
+          id: event.data.object.id,
+          partyId:
+            typeof event.data.object.customer === 'string'
+              ? event.data.object.customer
+              : event.data.object.customer.id,
+          partyType: 'USER' as PartyEnum[keyof PartyEnum],
+          description: event.data.object.description ?? undefined,
+          active: true,
+          providerFields: event.data.object,
+          externalId: event.data.object.id,
+          billingProvider: BillingProviderEnum.STRIPE,
+          startDate: new Date(event.data.object.created),
+          endDate: event.data.object.cancel_at
+            ? new Date(event.data.object.cancel_at)
+            : new Date(Infinity),
+          productId: event.data.object.items.data[0].plan.id,
+          status: event.data.object.status
+        });
+        break;
+      }
+
+      case 'customer.subscription.deleted': {
+        this.subscriptionService.deleteSubscription({
+          id: event.data.object.id
+        });
+        break;
+      }
+
+      case 'customer.subscription.paused': {
+        this.subscriptionService.cancelSubscription({
+          id: event.data.object.id
+        });
+        break;
+      }
+
+      case 'customer.subscription.resumed': {
+        this.subscriptionService.resumeSubscription({
+          id: event.data.object.id
+        });
+        break;
+      }
+
+      default:
+        this.openTelemetryCollector.info(
+          'Unprocessed stripe event type',
+          eventType
+        );
+        break;
+    }
+  }
+}

package/lib/eject/types/index.ts

@@ -0,0 +1,2 @@
+export * from './stripe.dto.types';
+export * from './stripe.entity.types';

package/lib/eject/types/stripe.dto.types.ts

@@ -0,0 +1,214 @@
+import {
+  BillingPortalDto,
+  CheckoutSessionDto,
+  CreateBillingPortalDto,
+  CreateCheckoutSessionDto,
+  CreatePaymentLinkDto,
+  CreatePlanDto,
+  CreateSubscriptionDto,
+  PaymentLinkDto,
+  PlanDto,
+  SubscriptionDto,
+  UpdateBillingPortalDto,
+  UpdateCheckoutSessionDto,
+  UpdatePaymentLinkDto,
+  UpdatePlanDto,
+  UpdateSubscriptionDto
+} from '@forklaunch/interfaces-billing/types';
+import Stripe from 'stripe';
+import { BillingProviderEnum } from '../domain/enums/billingProvider.enum';
+import { CurrencyEnum } from '../domain/enums/currency.enum';
+import { PaymentMethodEnum } from '../domain/enums/paymentMethod.enum';
+import { PlanCadenceEnum } from '../domain/enums/planCadence.enum';
+
+// Billing Portal Types
+type BillingPortalOmissions = 'customer';
+
+export type StripeCreateBillingPortalDto = Omit<
+  CreateBillingPortalDto,
+  'providerFields'
+> & {
+  stripeFields: Omit<
+    Stripe.BillingPortal.SessionCreateParams,
+    BillingPortalOmissions
+  >;
+};
+
+export type StripeUpdateBillingPortalDto = Omit<
+  UpdateBillingPortalDto,
+  'providerFields'
+> & {
+  stripeFields?: Omit<
+    Stripe.BillingPortal.SessionCreateParams,
+    BillingPortalOmissions
+  >;
+};
+
+export type StripeBillingPortalDto = Omit<
+  BillingPortalDto,
+  'providerFields'
+> & {
+  stripeFields: Stripe.BillingPortal.Session;
+};
+
+export type StripeBillingPortalDtos = {
+  BillingPortalMapper: StripeBillingPortalDto;
+  CreateBillingPortalMapper: StripeCreateBillingPortalDto;
+  UpdateBillingPortalMapper: StripeUpdateBillingPortalDto;
+};
+
+// Checkout Session Types
+type CheckoutSessionOmissions =
+  | 'payment_method_types'
+  | 'currency'
+  | 'success_url'
+  | 'cancel_url';
+
+export type StripeCreateCheckoutSessionDto<StatusEnum> = Omit<
+  CreateCheckoutSessionDto<
+    typeof PaymentMethodEnum,
+    typeof CurrencyEnum,
+    StatusEnum
+  >,
+  'providerFields'
+> & {
+  stripeFields: Omit<
+    Stripe.Checkout.SessionCreateParams,
+    CheckoutSessionOmissions
+  >;
+};
+
+export type StripeUpdateCheckoutSessionDto<StatusEnum> = Omit<
+  UpdateCheckoutSessionDto<
+    typeof PaymentMethodEnum,
+    typeof CurrencyEnum,
+    StatusEnum
+  >,
+  'providerFields'
+> & {
+  stripeFields?: Omit<
+    Stripe.Checkout.SessionCreateParams,
+    CheckoutSessionOmissions
+  >;
+};
+
+export type StripeCheckoutSessionDto<StatusEnum> = Omit<
+  CheckoutSessionDto<typeof PaymentMethodEnum, typeof CurrencyEnum, StatusEnum>,
+  'providerFields'
+> & {
+  stripeFields: Stripe.Checkout.Session;
+};
+
+export type StripeCheckoutSessionDtos<StatusEnum> = {
+  CheckoutSessionMapper: StripeCheckoutSessionDto<StatusEnum>;
+  CreateCheckoutSessionMapper: StripeCreateCheckoutSessionDto<StatusEnum>;
+  UpdateCheckoutSessionMapper: StripeUpdateCheckoutSessionDto<StatusEnum>;
+};
+
+// Payment Link Types
+export type StripeCreatePaymentLinkDto<StatusEnum> = Omit<
+  CreatePaymentLinkDto<
+    typeof PaymentMethodEnum,
+    typeof CurrencyEnum,
+    StatusEnum
+  >,
+  'providerFields'
+> & {
+  stripeFields: Stripe.PaymentLinkCreateParams;
+};
+
+export type StripeUpdatePaymentLinkDto<StatusEnum> = Omit<
+  UpdatePaymentLinkDto<
+    typeof PaymentMethodEnum,
+    typeof CurrencyEnum,
+    StatusEnum
+  >,
+  'providerFields'
+> & {
+  stripeFields?: Stripe.PaymentLinkUpdateParams;
+};
+
+export type StripePaymentLinkDto<StatusEnum> = Omit<
+  PaymentLinkDto<typeof PaymentMethodEnum, typeof CurrencyEnum, StatusEnum>,
+  'providerFields'
+> & {
+  stripeFields: Stripe.PaymentLink;
+};
+
+export type StripePaymentLinkDtos<StatusEnum> = {
+  PaymentLinkMapper: StripePaymentLinkDto<StatusEnum>;
+  CreatePaymentLinkMapper: StripeCreatePaymentLinkDto<StatusEnum>;
+  UpdatePaymentLinkMapper: StripeUpdatePaymentLinkDto<StatusEnum>;
+};
+
+// Plan Types
+type PlanOmissions = 'product' | 'interval' | 'currency';
+
+export type StripeCreatePlanDto = Omit<
+  CreatePlanDto<
+    typeof PlanCadenceEnum,
+    typeof CurrencyEnum,
+    typeof BillingProviderEnum
+  >,
+  'providerFields'
+> & {
+  stripeFields: Omit<Stripe.PlanCreateParams, PlanOmissions>;
+};
+
+export type StripeUpdatePlanDto = Omit<
+  UpdatePlanDto<
+    typeof PlanCadenceEnum,
+    typeof CurrencyEnum,
+    typeof BillingProviderEnum
+  >,
+  'providerFields'
+> & {
+  stripeFields?: Omit<Stripe.PlanUpdateParams, PlanOmissions>;
+};
+
+export type StripePlanDto = Omit<
+  PlanDto<
+    typeof PlanCadenceEnum,
+    typeof CurrencyEnum,
+    typeof BillingProviderEnum
+  >,
+  'providerFields'
+> & {
+  stripeFields: Stripe.Plan;
+};
+
+export type StripePlanDtos = {
+  PlanMapper: StripePlanDto;
+  CreatePlanMapper: StripeCreatePlanDto;
+  UpdatePlanMapper: StripeUpdatePlanDto;
+};
+
+// Subscription Types
+type SubscriptionOmissions = 'items' | 'customer';
+
+export type StripeCreateSubscriptionDto<PartyType> = Omit<
+  CreateSubscriptionDto<PartyType, typeof BillingProviderEnum>,
+  'providerFields'
+> & {
+  stripeFields: Omit<Stripe.SubscriptionCreateParams, SubscriptionOmissions>;
+};
+
+export type StripeUpdateSubscriptionDto<PartyType> = Omit<
+  UpdateSubscriptionDto<PartyType, typeof BillingProviderEnum>,
+  'providerFields'
+> & {
+  stripeFields?: Omit<Stripe.SubscriptionUpdateParams, SubscriptionOmissions>;
+};
+
+export type StripeSubscriptionDto<PartyType> = Omit<
+  SubscriptionDto<PartyType, typeof BillingProviderEnum>,
+  'providerFields'
+> & {
+  stripeFields: Stripe.Subscription;
+};
+
+export type StripeSubscriptionDtos<PartyType> = {
+  SubscriptionMapper: StripeSubscriptionDto<PartyType>;
+  CreateSubscriptionMapper: StripeCreateSubscriptionDto<PartyType>;
+  UpdateSubscriptionMapper: StripeUpdateSubscriptionDto<PartyType>;
+};

package/lib/eject/types/stripe.entity.types.ts

@@ -0,0 +1,83 @@
+import {
+  BillingPortalDto,
+  CheckoutSessionDto,
+  PaymentLinkDto,
+  PlanDto,
+  SubscriptionDto
+} from '@forklaunch/interfaces-billing/types';
+import Stripe from 'stripe';
+import { BillingProviderEnum } from '../domain/enums/billingProvider.enum';
+import { CurrencyEnum } from '../domain/enums/currency.enum';
+import { PaymentMethodEnum } from '../domain/enums/paymentMethod.enum';
+import { PlanCadenceEnum } from '../domain/enums/planCadence.enum';
+
+// Billing Portal Types
+export type StripeBillingPortalEntity = BillingPortalDto & {
+  providerFields: Stripe.BillingPortal.Session;
+};
+
+export type StripeBillingPortalEntities = {
+  BillingPortalMapper: StripeBillingPortalEntity;
+  CreateBillingPortalMapper: StripeBillingPortalEntity;
+  UpdateBillingPortalMapper: StripeBillingPortalEntity;
+};
+
+// Checkout Session Types
+
+export type StripeCheckoutSessionEntity<StatusEnum> = CheckoutSessionDto<
+  typeof PaymentMethodEnum,
+  typeof CurrencyEnum,
+  StatusEnum
+> & {
+  providerFields: Stripe.Checkout.Session;
+};
+
+export type StripeCheckoutSessionEntities<StatusEnum> = {
+  CheckoutSessionMapper: StripeCheckoutSessionEntity<StatusEnum>;
+  CreateCheckoutSessionMapper: StripeCheckoutSessionEntity<StatusEnum>;
+  UpdateCheckoutSessionMapper: StripeCheckoutSessionEntity<StatusEnum>;
+};
+
+// Payment Link Types
+export type StripePaymentLinkEntity<StatusEnum> = PaymentLinkDto<
+  typeof PaymentMethodEnum,
+  typeof CurrencyEnum,
+  StatusEnum
+> & {
+  providerFields: Stripe.PaymentLink;
+};
+
+export type StripePaymentLinkEntities<StatusEnum> = {
+  PaymentLinkMapper: StripePaymentLinkEntity<StatusEnum>;
+  CreatePaymentLinkMapper: StripePaymentLinkEntity<StatusEnum>;
+  UpdatePaymentLinkMapper: StripePaymentLinkEntity<StatusEnum>;
+};
+
+// Plan Types
+export type StripePlanEntity = PlanDto<
+  typeof PlanCadenceEnum,
+  typeof CurrencyEnum,
+  typeof BillingProviderEnum
+> & {
+  providerFields: Stripe.Plan;
+};
+
+export type StripePlanEntities = {
+  PlanMapper: StripePlanEntity;
+  CreatePlanMapper: StripePlanEntity;
+  UpdatePlanMapper: StripePlanEntity;
+};
+
+// Subscription Types
+export type StripeSubscriptionEntity<PartyType> = SubscriptionDto<
+  PartyType,
+  typeof BillingProviderEnum
+> & {
+  providerFields: Stripe.Subscription;
+};
+
+export type StripeSubscriptionEntities<PartyType> = {
+  SubscriptionMapper: StripeSubscriptionEntity<PartyType>;
+  CreateSubscriptionMapper: StripeSubscriptionEntity<PartyType>;
+  UpdateSubscriptionMapper: StripeSubscriptionEntity<PartyType>;
+};