@forklaunch/implementation-billing-stripe 0.2.7 → 0.3.0

package/lib/eject/domain/types/billingPortal.mapper.types.ts

@@ -0,0 +1,31 @@
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import { StripeBillingPortalDtos } from './stripe.dto.types';
+import { StripeBillingPortalEntities } from './stripe.entity.types';
+
+export type StripeBillingPortalMappers<
+  Entities extends StripeBillingPortalEntities,
+  Dto extends StripeBillingPortalDtos
+> = {
+  BillingPortalMapper: {
+    toDto: (
+      entity: Entities['BillingPortalMapper']
+    ) => Promise<Dto['BillingPortalMapper']>;
+  };
+  CreateBillingPortalMapper: {
+    toEntity: (
+      dto: Dto['CreateBillingPortalMapper'],
+      em: EntityManager,
+      stripeSession: Stripe.BillingPortal.Session,
+      ...args: unknown[]
+    ) => Promise<Entities['CreateBillingPortalMapper']>;
+  };
+  UpdateBillingPortalMapper: {
+    toEntity: (
+      dto: Dto['UpdateBillingPortalMapper'],
+      em: EntityManager,
+      stripeSession: Stripe.BillingPortal.Session,
+      ...args: unknown[]
+    ) => Promise<Entities['UpdateBillingPortalMapper']>;
+  };
+};

package/lib/eject/domain/types/checkoutSession.mapper.types.ts

@@ -0,0 +1,32 @@
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import { StripeCheckoutSessionDtos } from './stripe.dto.types';
+import { StripeCheckoutSessionEntities } from './stripe.entity.types';
+
+export type StripeCheckoutSessionMappers<
+  StatusEnum,
+  Entities extends StripeCheckoutSessionEntities<StatusEnum>,
+  Dto extends StripeCheckoutSessionDtos<StatusEnum>
+> = {
+  CheckoutSessionMapper: {
+    toDto: (
+      entity: Entities['CheckoutSessionMapper']
+    ) => Promise<Dto['CheckoutSessionMapper']>;
+  };
+  CreateCheckoutSessionMapper: {
+    toEntity: (
+      dto: Dto['CreateCheckoutSessionMapper'],
+      em: EntityManager,
+      stripeSession: Stripe.Checkout.Session,
+      ...args: unknown[]
+    ) => Promise<Entities['CreateCheckoutSessionMapper']>;
+  };
+  UpdateCheckoutSessionMapper: {
+    toEntity: (
+      dto: Dto['UpdateCheckoutSessionMapper'],
+      em: EntityManager,
+      stripeSession: Stripe.Checkout.Session,
+      ...args: unknown[]
+    ) => Promise<Entities['UpdateCheckoutSessionMapper']>;
+  };
+};

package/lib/eject/domain/types/index.ts

@@ -1,2 +1,7 @@
+export * from './billingPortal.mapper.types';
+export * from './checkoutSession.mapper.types';
+export * from './paymentLink.mapper.types';
+export * from './plan.mapper.types';
 export * from './stripe.dto.types';
 export type * from './stripe.entity.types';
+export * from './subscription.mapper.types';

package/lib/eject/domain/types/paymentLink.mapper.types.ts

@@ -0,0 +1,32 @@
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import { StripePaymentLinkDtos } from './stripe.dto.types';
+import { StripePaymentLinkEntities } from './stripe.entity.types';
+
+export type StripePaymentLinkMappers<
+  StatusEnum,
+  Entities extends StripePaymentLinkEntities<StatusEnum>,
+  Dto extends StripePaymentLinkDtos<StatusEnum>
+> = {
+  PaymentLinkMapper: {
+    toDto: (
+      entity: Entities['PaymentLinkMapper']
+    ) => Promise<Dto['PaymentLinkMapper']>;
+  };
+  CreatePaymentLinkMapper: {
+    toEntity: (
+      dto: Dto['CreatePaymentLinkMapper'],
+      em: EntityManager,
+      stripePaymentLink: Stripe.PaymentLink,
+      ...args: unknown[]
+    ) => Promise<Entities['CreatePaymentLinkMapper']>;
+  };
+  UpdatePaymentLinkMapper: {
+    toEntity: (
+      dto: Dto['UpdatePaymentLinkMapper'],
+      em: EntityManager,
+      stripePaymentLink: Stripe.PaymentLink,
+      ...args: unknown[]
+    ) => Promise<Entities['UpdatePaymentLinkMapper']>;
+  };
+};

package/lib/eject/domain/types/plan.mapper.types.ts

@@ -0,0 +1,29 @@
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import { StripePlanDtos } from './stripe.dto.types';
+import { StripePlanEntities } from './stripe.entity.types';
+
+export type StripePlanMappers<
+  Entities extends StripePlanEntities,
+  Dto extends StripePlanDtos
+> = {
+  PlanMapper: {
+    toDto: (entity: Entities['PlanMapper']) => Promise<Dto['PlanMapper']>;
+  };
+  CreatePlanMapper: {
+    toEntity: (
+      dto: Dto['CreatePlanMapper'],
+      em: EntityManager,
+      stripePlan: Stripe.Plan,
+      ...args: unknown[]
+    ) => Promise<Entities['CreatePlanMapper']>;
+  };
+  UpdatePlanMapper: {
+    toEntity: (
+      dto: Dto['UpdatePlanMapper'],
+      em: EntityManager,
+      stripePlan: Stripe.Plan,
+      ...args: unknown[]
+    ) => Promise<Entities['UpdatePlanMapper']>;
+  };
+};

package/lib/eject/domain/types/subscription.mapper.types.ts

@@ -0,0 +1,32 @@
+import { EntityManager } from '@mikro-orm/core';
+import Stripe from 'stripe';
+import { StripeSubscriptionDtos } from './stripe.dto.types';
+import { StripeSubscriptionEntities } from './stripe.entity.types';
+
+export type StripeSubscriptionMappers<
+  PartyType,
+  Entities extends StripeSubscriptionEntities<PartyType>,
+  Dto extends StripeSubscriptionDtos<PartyType>
+> = {
+  SubscriptionMapper: {
+    toDto: (
+      entity: Entities['SubscriptionMapper']
+    ) => Promise<Dto['SubscriptionMapper']>;
+  };
+  CreateSubscriptionMapper: {
+    toEntity: (
+      dto: Dto['CreateSubscriptionMapper'],
+      em: EntityManager,
+      stripeSubscription: Stripe.Subscription,
+      ...args: unknown[]
+    ) => Promise<Entities['CreateSubscriptionMapper']>;
+  };
+  UpdateSubscriptionMapper: {
+    toEntity: (
+      dto: Dto['UpdateSubscriptionMapper'],
+      em: EntityManager,
+      stripeSubscription: Stripe.Subscription,
+      ...args: unknown[]
+    ) => Promise<Entities['UpdateSubscriptionMapper']>;
+  };
+};

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

@@ -1,4 +1,4 @@
-import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { IdDto } from '@forklaunch/common';
 import { TtlCache } from '@forklaunch/core/cache';
 import {
   MetricsDefinition,
@@ -6,20 +6,13 @@ import {
   TelemetryOptions
 } from '@forklaunch/core/http';
 import { BaseBillingPortalService } from '@forklaunch/implementation-billing-base/services';
+import { BillingPortalMappers } from '@forklaunch/implementation-billing-base/types';
 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 { StripeBillingPortalMappers } from '../domain/types/billingPortal.mapper.types';
 import {
-  StripeBillingPortalDto,
   StripeBillingPortalDtos,
   StripeCreateBillingPortalDto,
   StripeUpdateBillingPortalDto
@@ -32,52 +25,24 @@ export class StripeBillingPortalService<
   Dto extends StripeBillingPortalDtos = StripeBillingPortalDtos
 > implements
     BillingPortalService<{
-      CreateBillingPortalDto: StripeCreateBillingPortalDto;
-      UpdateBillingPortalDto: StripeUpdateBillingPortalDto;
-      BillingPortalDto: StripeBillingPortalDto;
+      CreateBillingPortalDto: Dto['CreateBillingPortalMapper'];
+      UpdateBillingPortalDto: Dto['UpdateBillingPortalMapper'];
+      BillingPortalDto: Dto['BillingPortalMapper'];
       IdDto: IdDto;
     }>
 {
-  private readonly billingPortalSessionExpiryDurationMs = 5 * 60 * 1000;
-
   baseBillingPortalService: BaseBillingPortalService<
     SchemaValidator,
     Entities,
-    Entities
+    Dto
   >;
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
-  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']>
-    >;
-  };
+  protected readonly stripeClient: Stripe;
+  protected readonly em: EntityManager;
+  protected readonly cache: TtlCache;
+  protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+  protected readonly schemaValidator: SchemaValidator;
+  private readonly billingPortalSessionExpiryDurationMs = 5 * 60 * 1000;
+  protected readonly mappers: StripeBillingPortalMappers<Entities, Dto>;
 
   constructor(
     stripeClient: Stripe,
@@ -85,36 +50,10 @@ export class StripeBillingPortalService<
     cache: TtlCache,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     schemaValidator: SchemaValidator,
-    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']>
-      >;
-    },
+    mappers: StripeBillingPortalMappers<Entities, Dto>,
     readonly options?: {
-      telemetry?: TelemetryOptions;
       enableDatabaseBackup?: boolean;
+      telemetry?: TelemetryOptions;
     }
   ) {
     this.stripeClient = stripeClient;
@@ -123,65 +62,48 @@ export class StripeBillingPortalService<
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
-    this.baseBillingPortalService = new BaseBillingPortalService(
+    this.baseBillingPortalService = new BaseBillingPortalService<
+      SchemaValidator,
+      Entities,
+      Dto
+    >(
       em,
       cache,
       openTelemetryCollector,
       schemaValidator,
-      {
-        BillingPortalMapper: IdentityResponseMapper<
-          Entities['BillingPortalMapper']
-        >,
-        CreateBillingPortalMapper: IdentityRequestMapper<
-          Entities['CreateBillingPortalMapper']
-        >,
-        UpdateBillingPortalMapper: IdentityRequestMapper<
-          Entities['UpdateBillingPortalMapper']
-        >
-      },
+      mappers as BillingPortalMappers<Entities, Dto>,
       options
     );
   }
 
   async createBillingPortalSession(
-    billingPortalDto: Dto['CreateBillingPortalMapper']
+    billingPortalDto: StripeCreateBillingPortalDto,
+    ...args: unknown[]
   ): 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 await this.baseBillingPortalService.createBillingPortalSession(
+      {
+        ...billingPortalDto,
+        id: session.id,
+        uri: session.url,
+        expiresAt: new Date(
+          Date.now() + this.billingPortalSessionExpiryDurationMs
         )
-      );
-
-    return this._mappers.BillingPortalMapper.serializeEntityToDto(
-      billingPortalEntity
+      },
+      this.em,
+      session,
+      ...args
     );
   }
 
   async getBillingPortalSession(
     idDto: IdDto
   ): Promise<Dto['BillingPortalMapper']> {
-    const billingPortalEntity =
-      await this.baseBillingPortalService.getBillingPortalSession(idDto);
-
-    return this._mappers.BillingPortalMapper.serializeEntityToDto(
-      billingPortalEntity
-    );
+    return await this.baseBillingPortalService.getBillingPortalSession(idDto);
   }
 
   async expireBillingPortalSession(idDto: IdDto): Promise<void> {
@@ -189,7 +111,8 @@ export class StripeBillingPortalService<
   }
 
   async updateBillingPortalSession(
-    billingPortalDto: Dto['UpdateBillingPortalMapper']
+    billingPortalDto: StripeUpdateBillingPortalDto,
+    ...args: unknown[]
   ): Promise<Dto['BillingPortalMapper']> {
     const existingSession =
       await this.baseBillingPortalService.getBillingPortalSession({
@@ -200,24 +123,18 @@ export class StripeBillingPortalService<
       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 await this.baseBillingPortalService.updateBillingPortalSession(
+      {
+        ...billingPortalDto,
+        id: session.id,
+        uri: session.url,
+        expiresAt: new Date(
+          Date.now() + this.billingPortalSessionExpiryDurationMs
         )
-      );
-
-    return this._mappers.BillingPortalMapper.serializeEntityToDto(
-      baseBillingPortalDto
+      },
+      this.em,
+      session,
+      ...args
     );
   }
 }

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

@@ -1,4 +1,4 @@
-import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { IdDto } from '@forklaunch/common';
 import { TtlCache } from '@forklaunch/core/cache';
 import {
   MetricsDefinition,
@@ -6,21 +6,18 @@ import {
   TelemetryOptions
 } from '@forklaunch/core/http';
 import { BaseCheckoutSessionService } from '@forklaunch/implementation-billing-base/services';
+import { CheckoutSessionMappers } from '@forklaunch/implementation-billing-base/types';
 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/enum/currency.enum';
 import { PaymentMethodEnum } from '../domain/enum/paymentMethod.enum';
-import { StripeCheckoutSessionDtos } from '../domain/types/stripe.dto.types';
+import { StripeCheckoutSessionMappers } from '../domain/types/checkoutSession.mapper.types';
+import {
+  StripeCheckoutSessionDtos,
+  StripeCreateCheckoutSessionDto
+} from '../domain/types/stripe.dto.types';
 import { StripeCheckoutSessionEntities } from '../domain/types/stripe.entity.types';
 
 export class StripeCheckoutSessionService<
@@ -43,45 +40,22 @@ export class StripeCheckoutSessionService<
 {
   baseCheckoutSessionService: BaseCheckoutSessionService<
     SchemaValidator,
-    typeof PaymentMethodEnum,
-    typeof CurrencyEnum,
+    PaymentMethodEnum,
+    CurrencyEnum,
     StatusEnum,
     Entities,
-    Entities
+    Dto
   >;
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   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']>
-    >;
-  };
+  protected readonly mappers: StripeCheckoutSessionMappers<
+    StatusEnum,
+    Entities,
+    Dto
+  >;
 
   constructor(
     stripeClient: Stripe,
@@ -89,33 +63,7 @@ export class StripeCheckoutSessionService<
     cache: TtlCache,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     schemaValidator: SchemaValidator,
-    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']>
-      >;
-    },
+    mappers: StripeCheckoutSessionMappers<StatusEnum, Entities, Dto>,
     readonly options?: {
       enableDatabaseBackup?: boolean;
       telemetry?: TelemetryOptions;
@@ -127,29 +75,25 @@ export class StripeCheckoutSessionService<
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    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']
-        >
-      },
+      mappers as CheckoutSessionMappers<
+        PaymentMethodEnum,
+        CurrencyEnum,
+        StatusEnum,
+        Entities,
+        Dto
+      >,
       options
     );
   }
 
   async createCheckoutSession(
-    checkoutSessionDto: Dto['CreateCheckoutSessionMapper']
+    checkoutSessionDto: StripeCreateCheckoutSessionDto<StatusEnum>,
+    ...args: unknown[]
   ): Promise<Dto['CheckoutSessionMapper']> {
     const session = await this.stripeClient.checkout.sessions.create({
       ...checkoutSessionDto.stripeFields,
@@ -159,37 +103,32 @@ export class StripeCheckoutSessionService<
       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
+    return await this.baseCheckoutSessionService.createCheckoutSession(
+      {
+        ...checkoutSessionDto,
+        id: session.id,
+        uri: session.url ?? undefined,
+        expiresAt: new Date(Date.now() + 5 * 60 * 1000),
+        providerFields: session
+      },
+      this.em,
+      session,
+      ...args
     );
   }
 
-  async getCheckoutSession({
-    id
-  }: IdDto): Promise<Dto['CheckoutSessionMapper']> {
+  async getCheckoutSession(
+    idDto: IdDto
+  ): Promise<Dto['CheckoutSessionMapper']> {
+    const session = await this.stripeClient.checkout.sessions.retrieve(
+      idDto.id
+    );
     const databaseCheckoutSession =
-      await this.baseCheckoutSessionService.getCheckoutSession({ id });
-    return {
-      ...this._mappers.CheckoutSessionMapper.serializeEntityToDto(
-        databaseCheckoutSession
-      ),
-      stripeFields: await this.stripeClient.checkout.sessions.retrieve(id)
-    };
+      await this.baseCheckoutSessionService.getCheckoutSession(idDto);
+
+    databaseCheckoutSession.stripeFields = session;
+
+    return databaseCheckoutSession;
   }
 
   async expireCheckoutSession({ id }: IdDto): Promise<void> {