@forklaunch/implementation-billing-stripe 0.0.1

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

@@ -0,0 +1,185 @@
+import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { TtlCache } from '@forklaunch/core/cache';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
+import { BaseBillingPortalService } from '@forklaunch/implementation-billing-base/services';
+import { BillingPortalService } from '@forklaunch/interfaces-billing/interfaces';
+import {
+  IdentityRequestMapper,
+  IdentityResponseMapper,
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import {
+  StripeBillingPortalDto,
+  StripeBillingPortalDtos,
+  StripeCreateBillingPortalDto,
+  StripeUpdateBillingPortalDto
+} from '../types/stripe.dto.types';
+import { StripeBillingPortalEntities } from '../types/stripe.entity.types';
+
+export class StripeBillingPortalService<
+  SchemaValidator extends AnySchemaValidator,
+  Entities extends StripeBillingPortalEntities,
+  Dto extends StripeBillingPortalDtos = StripeBillingPortalDtos
+> implements
+    BillingPortalService<{
+      CreateBillingPortalDto: StripeCreateBillingPortalDto;
+      UpdateBillingPortalDto: StripeUpdateBillingPortalDto;
+      BillingPortalDto: StripeBillingPortalDto;
+      IdDto: IdDto;
+    }>
+{
+  private readonly billingPortalSessionExpiryDurationMs = 5 * 60 * 1000;
+
+  baseBillingPortalService: BaseBillingPortalService<
+    SchemaValidator,
+    Entities,
+    Entities
+  >;
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+
+  constructor(
+    protected stripeClient: Stripe,
+    protected em: EntityManager,
+    protected cache: TtlCache,
+    protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    protected schemaValidator: SchemaValidator,
+    protected mappers: {
+      BillingPortalMapper: ResponseMapperConstructor<
+        SchemaValidator,
+        Dto['BillingPortalMapper'],
+        Entities['BillingPortalMapper']
+      >;
+      CreateBillingPortalMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['CreateBillingPortalMapper'],
+        Entities['CreateBillingPortalMapper'],
+        (
+          dto: Dto['CreateBillingPortalMapper'],
+          em: EntityManager,
+          session: Stripe.BillingPortal.Session
+        ) => Promise<Entities['CreateBillingPortalMapper']>
+      >;
+      UpdateBillingPortalMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateBillingPortalMapper'],
+        Entities['UpdateBillingPortalMapper'],
+        (
+          dto: Dto['UpdateBillingPortalMapper'],
+          em: EntityManager,
+          session: Stripe.BillingPortal.Session
+        ) => Promise<Entities['UpdateBillingPortalMapper']>
+      >;
+    },
+    readonly options?: {
+      telemetry?: TelemetryOptions;
+      enableDatabaseBackup?: boolean;
+    }
+  ) {
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
+    this.baseBillingPortalService = new BaseBillingPortalService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        BillingPortalMapper: IdentityResponseMapper<
+          Entities['BillingPortalMapper']
+        >,
+        CreateBillingPortalMapper: IdentityRequestMapper<
+          Entities['CreateBillingPortalMapper']
+        >,
+        UpdateBillingPortalMapper: IdentityRequestMapper<
+          Entities['UpdateBillingPortalMapper']
+        >
+      },
+      options
+    );
+  }
+
+  async createBillingPortalSession(
+    billingPortalDto: Dto['CreateBillingPortalMapper']
+  ): Promise<Dto['BillingPortalMapper']> {
+    const session = await this.stripeClient.billingPortal.sessions.create({
+      ...billingPortalDto.stripeFields,
+      customer: billingPortalDto.customerId
+    });
+
+    const billingPortalEntity =
+      await this.baseBillingPortalService.createBillingPortalSession(
+        await this._mappers.CreateBillingPortalMapper.deserializeDtoToEntity(
+          {
+            ...billingPortalDto,
+            id: session.id,
+            uri: session.url,
+            expiresAt: new Date(
+              Date.now() + this.billingPortalSessionExpiryDurationMs
+            )
+          },
+          this.em,
+          session
+        )
+      );
+
+    return this._mappers.BillingPortalMapper.serializeEntityToDto(
+      billingPortalEntity
+    );
+  }
+
+  async getBillingPortalSession(
+    idDto: IdDto
+  ): Promise<Dto['BillingPortalMapper']> {
+    const billingPortalEntity =
+      await this.baseBillingPortalService.getBillingPortalSession(idDto);
+
+    return this._mappers.BillingPortalMapper.serializeEntityToDto(
+      billingPortalEntity
+    );
+  }
+
+  async expireBillingPortalSession(idDto: IdDto): Promise<void> {
+    return this.baseBillingPortalService.expireBillingPortalSession(idDto);
+  }
+
+  async updateBillingPortalSession(
+    billingPortalDto: Dto['UpdateBillingPortalMapper']
+  ): Promise<Dto['BillingPortalMapper']> {
+    const existingSession =
+      await this.baseBillingPortalService.getBillingPortalSession({
+        id: billingPortalDto.id
+      });
+    const session = await this.stripeClient.billingPortal.sessions.create({
+      ...billingPortalDto.stripeFields,
+      customer: existingSession.customerId
+    });
+
+    const baseBillingPortalDto =
+      await this.baseBillingPortalService.updateBillingPortalSession(
+        await this._mappers.UpdateBillingPortalMapper.deserializeDtoToEntity(
+          {
+            ...billingPortalDto,
+            id: session.id,
+            uri: session.url,
+            expiresAt: new Date(
+              Date.now() + this.billingPortalSessionExpiryDurationMs
+            )
+          },
+          this.em,
+          session
+        )
+      );
+
+    return this._mappers.BillingPortalMapper.serializeEntityToDto(
+      baseBillingPortalDto
+    );
+  }
+}

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

@@ -0,0 +1,179 @@
+import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { TtlCache } from '@forklaunch/core/cache';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
+import { BaseCheckoutSessionService } from '@forklaunch/implementation-billing-base/services';
+import { CheckoutSessionService } from '@forklaunch/interfaces-billing/interfaces';
+import {
+  IdentityRequestMapper,
+  IdentityResponseMapper,
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import { CurrencyEnum } from '../domain/enums/currency.enum';
+import { PaymentMethodEnum } from '../domain/enums/paymentMethod.enum';
+import { StripeCheckoutSessionDtos } from '../types/stripe.dto.types';
+import { StripeCheckoutSessionEntities } from '../types/stripe.entity.types';
+
+export class StripeCheckoutSessionService<
+  SchemaValidator extends AnySchemaValidator,
+  StatusEnum,
+  Entities extends StripeCheckoutSessionEntities<StatusEnum>,
+  Dto extends
+    StripeCheckoutSessionDtos<StatusEnum> = StripeCheckoutSessionDtos<StatusEnum>
+> implements
+    CheckoutSessionService<
+      typeof PaymentMethodEnum,
+      typeof CurrencyEnum,
+      StatusEnum,
+      {
+        CreateCheckoutSessionDto: Dto['CreateCheckoutSessionMapper'];
+        CheckoutSessionDto: Dto['CheckoutSessionMapper'];
+        IdDto: IdDto;
+      }
+    >
+{
+  baseCheckoutSessionService: BaseCheckoutSessionService<
+    SchemaValidator,
+    typeof PaymentMethodEnum,
+    typeof CurrencyEnum,
+    StatusEnum,
+    Entities,
+    Entities
+  >;
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+
+  constructor(
+    protected readonly stripeClient: Stripe,
+    protected readonly em: EntityManager,
+    protected readonly cache: TtlCache,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    protected readonly schemaValidator: SchemaValidator,
+    protected readonly mappers: {
+      CheckoutSessionMapper: ResponseMapperConstructor<
+        SchemaValidator,
+        Dto['CheckoutSessionMapper'],
+        Entities['CheckoutSessionMapper']
+      >;
+      CreateCheckoutSessionMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['CreateCheckoutSessionMapper'],
+        Entities['CreateCheckoutSessionMapper'],
+        (
+          dto: Dto['CreateCheckoutSessionMapper'],
+          em: EntityManager,
+          session: Stripe.Checkout.Session
+        ) => Promise<Entities['CreateCheckoutSessionMapper']>
+      >;
+      UpdateCheckoutSessionMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateCheckoutSessionMapper'],
+        Entities['UpdateCheckoutSessionMapper'],
+        (
+          dto: Dto['UpdateCheckoutSessionMapper'],
+          em: EntityManager,
+          session: Stripe.Checkout.Session
+        ) => Promise<Entities['UpdateCheckoutSessionMapper']>
+      >;
+    },
+    readonly options?: {
+      enableDatabaseBackup?: boolean;
+      telemetry?: TelemetryOptions;
+    }
+  ) {
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
+    this.baseCheckoutSessionService = new BaseCheckoutSessionService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        CheckoutSessionMapper: IdentityResponseMapper<
+          Entities['CheckoutSessionMapper']
+        >,
+        CreateCheckoutSessionMapper: IdentityRequestMapper<
+          Entities['CreateCheckoutSessionMapper']
+        >,
+        UpdateCheckoutSessionMapper: IdentityRequestMapper<
+          Entities['UpdateCheckoutSessionMapper']
+        >
+      },
+      options
+    );
+  }
+
+  async createCheckoutSession(
+    checkoutSessionDto: Dto['CreateCheckoutSessionMapper']
+  ): Promise<Dto['CheckoutSessionMapper']> {
+    const session = await this.stripeClient.checkout.sessions.create({
+      ...checkoutSessionDto.stripeFields,
+      payment_method_types: checkoutSessionDto.paymentMethods,
+      currency: checkoutSessionDto.currency as string,
+      success_url: checkoutSessionDto.successRedirectUri,
+      cancel_url: checkoutSessionDto.cancelRedirectUri
+    });
+
+    const checkoutSessionEntity =
+      await this.baseCheckoutSessionService.createCheckoutSession(
+        await this._mappers.CreateCheckoutSessionMapper.deserializeDtoToEntity(
+          {
+            ...checkoutSessionDto,
+            id: session.id,
+            uri: session.url,
+            expiresAt: new Date(Date.now() + 5 * 60 * 1000),
+            providerFields: session
+          },
+          this.em,
+          session
+        )
+      );
+
+    return this._mappers.CheckoutSessionMapper.serializeEntityToDto(
+      checkoutSessionEntity
+    );
+  }
+
+  async getCheckoutSession({
+    id
+  }: IdDto): Promise<Dto['CheckoutSessionMapper']> {
+    const databaseCheckoutSession =
+      await this.baseCheckoutSessionService.getCheckoutSession({ id });
+    return {
+      ...this._mappers.CheckoutSessionMapper.serializeEntityToDto(
+        databaseCheckoutSession
+      ),
+      stripeFields: await this.stripeClient.checkout.sessions.retrieve(id)
+    };
+  }
+
+  async expireCheckoutSession({ id }: IdDto): Promise<void> {
+    await this.stripeClient.checkout.sessions.expire(id);
+    await this.baseCheckoutSessionService.expireCheckoutSession({ id });
+  }
+
+  async handleCheckoutSuccess({ id }: IdDto): Promise<void> {
+    await this.stripeClient.checkout.sessions.update(id, {
+      metadata: {
+        status: 'SUCCESS'
+      }
+    });
+    await this.baseCheckoutSessionService.handleCheckoutSuccess({ id });
+  }
+
+  async handleCheckoutFailure({ id }: IdDto): Promise<void> {
+    await this.stripeClient.checkout.sessions.update(id, {
+      metadata: {
+        status: 'FAILED'
+      }
+    });
+    await this.baseCheckoutSessionService.handleCheckoutFailure({ id });
+  }
+}

package/lib/eject/services/index.ts

@@ -0,0 +1,6 @@
+export * from './billingPortal.service';
+export * from './checkoutSession.service';
+export * from './paymentLink.service';
+export * from './plan.service';
+export * from './subscription.service';
+export * from './webhook.service';

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

@@ -0,0 +1,239 @@
+import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import { TtlCache } from '@forklaunch/core/cache';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
+import { BasePaymentLinkService } from '@forklaunch/implementation-billing-base/services';
+import { PaymentLinkService } from '@forklaunch/interfaces-billing/interfaces';
+import {
+  IdentityRequestMapper,
+  IdentityResponseMapper,
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import { CurrencyEnum } from '../domain/enums/currency.enum';
+import { PaymentMethodEnum } from '../domain/enums/paymentMethod.enum';
+import {
+  StripeCreatePaymentLinkDto,
+  StripePaymentLinkDto,
+  StripePaymentLinkDtos,
+  StripeUpdatePaymentLinkDto
+} from '../types/stripe.dto.types';
+import { StripePaymentLinkEntities } from '../types/stripe.entity.types';
+
+export class StripePaymentLinkService<
+  SchemaValidator extends AnySchemaValidator,
+  StatusEnum,
+  Entities extends StripePaymentLinkEntities<StatusEnum>,
+  Dto extends
+    StripePaymentLinkDtos<StatusEnum> = StripePaymentLinkDtos<StatusEnum>
+> implements
+    PaymentLinkService<
+      PaymentMethodEnum,
+      CurrencyEnum,
+      StatusEnum,
+      {
+        CreatePaymentLinkDto: StripeCreatePaymentLinkDto<StatusEnum>;
+        UpdatePaymentLinkDto: StripeUpdatePaymentLinkDto<StatusEnum>;
+        PaymentLinkDto: StripePaymentLinkDto<StatusEnum>;
+        IdDto: IdDto;
+        IdsDto: IdsDto;
+      }
+    >
+{
+  basePaymentLinkService: BasePaymentLinkService<
+    SchemaValidator,
+    typeof PaymentMethodEnum,
+    typeof CurrencyEnum,
+    StatusEnum,
+    Entities,
+    Entities
+  >;
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+
+  constructor(
+    protected readonly stripeClient: Stripe,
+    protected readonly em: EntityManager,
+    protected readonly cache: TtlCache,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    protected readonly schemaValidator: SchemaValidator,
+    protected readonly mappers: {
+      PaymentLinkMapper: ResponseMapperConstructor<
+        SchemaValidator,
+        Dto['PaymentLinkMapper'],
+        Entities['PaymentLinkMapper']
+      >;
+      CreatePaymentLinkMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['CreatePaymentLinkMapper'],
+        Entities['CreatePaymentLinkMapper'],
+        (
+          dto: Dto['CreatePaymentLinkMapper'],
+          em: EntityManager,
+          paymentLink: Stripe.PaymentLink
+        ) => Promise<Entities['CreatePaymentLinkMapper']>
+      >;
+      UpdatePaymentLinkMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['UpdatePaymentLinkMapper'],
+        Entities['UpdatePaymentLinkMapper'],
+        (
+          dto: Dto['UpdatePaymentLinkMapper'],
+          em: EntityManager,
+          paymentLink: Stripe.PaymentLink
+        ) => Promise<Entities['UpdatePaymentLinkMapper']>
+      >;
+    },
+    readonly options?: {
+      enableDatabaseBackup?: boolean;
+      telemetry?: TelemetryOptions;
+    }
+  ) {
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
+    this.basePaymentLinkService = new BasePaymentLinkService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        PaymentLinkMapper: IdentityResponseMapper<
+          Entities['PaymentLinkMapper']
+        >,
+        CreatePaymentLinkMapper: IdentityRequestMapper<
+          Entities['CreatePaymentLinkMapper']
+        >,
+        UpdatePaymentLinkMapper: IdentityRequestMapper<
+          Entities['UpdatePaymentLinkMapper']
+        >
+      },
+      options
+    );
+  }
+
+  async createPaymentLink(
+    paymentLinkDto: Dto['CreatePaymentLinkMapper']
+  ): Promise<Dto['PaymentLinkMapper']> {
+    const session = await this.stripeClient.paymentLinks.create({
+      ...paymentLinkDto.stripeFields,
+      payment_method_types: paymentLinkDto.paymentMethods,
+      currency: paymentLinkDto.currency as string
+    });
+
+    const paymentLinkEntity =
+      await this.basePaymentLinkService.createPaymentLink(
+        await this._mappers.CreatePaymentLinkMapper.deserializeDtoToEntity(
+          {
+            ...paymentLinkDto,
+            id: session.id,
+            amount:
+              session.line_items?.data.reduce<number>(
+                (total, item) => total + item.amount_total,
+                0
+              ) ?? 0
+          },
+          this.em,
+          session
+        )
+      );
+
+    return this._mappers.PaymentLinkMapper.serializeEntityToDto(
+      paymentLinkEntity
+    );
+  }
+
+  async updatePaymentLink(
+    paymentLinkDto: Dto['UpdatePaymentLinkMapper']
+  ): Promise<Dto['PaymentLinkMapper']> {
+    const session = await this.stripeClient.paymentLinks.update(
+      paymentLinkDto.id,
+      {
+        ...paymentLinkDto.stripeFields,
+        payment_method_types: paymentLinkDto.paymentMethods
+      }
+    );
+
+    const paymentLinkEntity =
+      await this.basePaymentLinkService.updatePaymentLink(
+        await this._mappers.UpdatePaymentLinkMapper.deserializeDtoToEntity(
+          {
+            ...paymentLinkDto,
+            id: session.id,
+            amount:
+              session.line_items?.data.reduce<number>(
+                (total, item) => total + item.amount_total,
+                0
+              ) ?? 0
+          },
+          this.em,
+          session
+        )
+      );
+
+    return this._mappers.PaymentLinkMapper.serializeEntityToDto(
+      paymentLinkEntity
+    );
+  }
+
+  async getPaymentLink({ id }: IdDto): Promise<Dto['PaymentLinkMapper']> {
+    const databasePaymentLink =
+      await this.basePaymentLinkService.getPaymentLink({ id });
+    return {
+      ...this._mappers.PaymentLinkMapper.serializeEntityToDto(
+        databasePaymentLink
+      ),
+      stripeFields: await this.stripeClient.paymentLinks.retrieve(id)
+    };
+  }
+
+  async expirePaymentLink({ id }: IdDto): Promise<void> {
+    await this.stripeClient.paymentLinks.update(id, {
+      metadata: {
+        status: 'EXPIRED'
+      }
+    });
+    await this.basePaymentLinkService.expirePaymentLink({ id });
+  }
+
+  async handlePaymentSuccess({ id }: IdDto): Promise<void> {
+    await this.stripeClient.paymentLinks.update(id, {
+      metadata: {
+        status: 'COMPLETED'
+      }
+    });
+    await this.basePaymentLinkService.handlePaymentSuccess({ id });
+  }
+
+  async handlePaymentFailure({ id }: IdDto): Promise<void> {
+    await this.stripeClient.paymentLinks.update(id, {
+      metadata: {
+        status: 'FAILED'
+      }
+    });
+    await this.basePaymentLinkService.handlePaymentFailure({ id });
+  }
+
+  async listPaymentLinks(idsDto?: IdsDto): Promise<Dto['PaymentLinkMapper'][]> {
+    const paymentLinks = await this.stripeClient.paymentLinks.list({
+      active: true
+    });
+    return await Promise.all(
+      (await this.basePaymentLinkService.listPaymentLinks(idsDto)).map(
+        async (paymentLink) => ({
+          ...(await this._mappers.PaymentLinkMapper.serializeEntityToDto(
+            paymentLink
+          )),
+          stripeFields: paymentLinks.data.find(
+            (paymentLink) => paymentLink.id === paymentLink.id
+          )
+        })
+      )
+    );
+  }
+}