@forklaunch/implementation-billing-base 0.3.2 → 0.3.3

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

@@ -6,102 +6,71 @@ import {
   OpenTelemetryCollector,
   TelemetryOptions
 } from '@forklaunch/core/http';
-import {
-  InternalDtoMapper,
-  RequestDtoMapperConstructor,
-  ResponseDtoMapperConstructor,
-  transformIntoInternalDtoMapper
-} from '@forklaunch/core/mappers';
 import { CheckoutSessionService } from '@forklaunch/interfaces-billing/interfaces';
 import {
-  CheckoutSessionDto,
-  CreateCheckoutSessionDto,
-  UpdateCheckoutSessionDto
-} from '@forklaunch/interfaces-billing/types';
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
+import { BaseCheckoutSessionDtos } from '../types/baseBillingDto.types';
+import { BaseCheckoutSessionEntities } from '../types/baseBillingEntity.types';
 
 export class BaseCheckoutSessionService<
   SchemaValidator extends AnySchemaValidator,
   PaymentMethodEnum,
+  CurrencyEnum,
   StatusEnum,
-  Metrics extends MetricsDefinition = MetricsDefinition,
-  Dto extends {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<
-      PaymentMethodEnum,
-      StatusEnum
-    >;
-    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<
-      PaymentMethodEnum,
-      StatusEnum
-    >;
-  } = {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<
-      PaymentMethodEnum,
-      StatusEnum
-    >;
-    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<
-      PaymentMethodEnum,
-      StatusEnum
-    >;
-  },
-  Entities extends {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<
-      PaymentMethodEnum,
-      StatusEnum
-    >;
-    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<
-      PaymentMethodEnum,
-      StatusEnum
-    >;
-  } = {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<
-      PaymentMethodEnum,
-      StatusEnum
-    >;
-    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<
-      PaymentMethodEnum,
-      StatusEnum
-    >;
-  }
-> implements CheckoutSessionService<PaymentMethodEnum, StatusEnum>
+  Entities extends BaseCheckoutSessionEntities<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >,
+  Dto extends BaseCheckoutSessionDtos<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  > = BaseCheckoutSessionDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum>
+> implements CheckoutSessionService<PaymentMethodEnum, CurrencyEnum, StatusEnum>
 {
-  #mappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mappers>,
-    Entities,
-    Dto
-  >;
-  private evaluatedTelemetryOptions: {
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+  protected evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
     tracing?: boolean;
   };
-  private enableDatabaseBackup: boolean;
+  protected enableDatabaseBackup: boolean;
 
   constructor(
     protected readonly em: EntityManager,
     protected readonly cache: TtlCache,
-    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     protected readonly schemaValidator: SchemaValidator,
     protected readonly mappers: {
-      CheckoutSessionDtoMapper: ResponseDtoMapperConstructor<
+      CheckoutSessionMapper: ResponseMapperConstructor<
         SchemaValidator,
-        Dto['CheckoutSessionDtoMapper'],
-        Entities['CheckoutSessionDtoMapper']
+        Dto['CheckoutSessionMapper'],
+        Entities['CheckoutSessionMapper']
       >;
-      CreateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<
+      CreateCheckoutSessionMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['CreateCheckoutSessionDtoMapper'],
-        Entities['CreateCheckoutSessionDtoMapper']
+        Dto['CreateCheckoutSessionMapper'],
+        Entities['CreateCheckoutSessionMapper'],
+        (
+          dto: Dto['CreateCheckoutSessionMapper'],
+          em: EntityManager
+        ) => Promise<Entities['CreateCheckoutSessionMapper']>
       >;
-      UpdateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<
+      UpdateCheckoutSessionMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['UpdateCheckoutSessionDtoMapper'],
-        Entities['UpdateCheckoutSessionDtoMapper']
+        Dto['UpdateCheckoutSessionMapper'],
+        Entities['UpdateCheckoutSessionMapper'],
+        (
+          dto: Dto['UpdateCheckoutSessionMapper'],
+          em: EntityManager
+        ) => Promise<Entities['UpdateCheckoutSessionMapper']>
       >;
     },
     readonly options?: {
@@ -109,7 +78,7 @@ export class BaseCheckoutSessionService<
       telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
@@ -123,8 +92,8 @@ export class BaseCheckoutSessionService<
   protected createCacheKey = createCacheKey('checkout_session');
 
   async createCheckoutSession(
-    checkoutSessionDto: Dto['CreateCheckoutSessionDtoMapper']
-  ): Promise<Dto['CheckoutSessionDtoMapper']> {
+    checkoutSessionDto: Dto['CreateCheckoutSessionMapper']
+  ): Promise<Dto['CheckoutSessionMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
         'Creating checkout session',
@@ -133,13 +102,13 @@ export class BaseCheckoutSessionService<
     }
 
     const checkoutSession =
-      await this.#mappers.CreateCheckoutSessionDtoMapper.deserializeDtoToEntity(
+      await this._mappers.CreateCheckoutSessionMapper.deserializeDtoToEntity(
         checkoutSessionDto,
         this.em
       );
 
     const createdCheckoutSessionDto =
-      await this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+      await this._mappers.CheckoutSessionMapper.serializeEntityToDto(
         checkoutSession
       );
 
@@ -158,15 +127,15 @@ export class BaseCheckoutSessionService<
 
   async getCheckoutSession({
     id
-  }: IdDto): Promise<Dto['CheckoutSessionDtoMapper']> {
+  }: IdDto): Promise<Dto['CheckoutSessionMapper']> {
     const checkoutSessionDetails = await this.cache.readRecord<
-      Entities['CheckoutSessionDtoMapper']
+      Entities['CheckoutSessionMapper']
     >(this.createCacheKey(id));
     if (!checkoutSessionDetails) {
       throw new Error('Session not found');
     }
 
-    return this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+    return this._mappers.CheckoutSessionMapper.serializeEntityToDto(
       checkoutSessionDetails.value
     );
   }

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

@@ -6,78 +6,71 @@ import {
   OpenTelemetryCollector,
   TelemetryOptions
 } from '@forklaunch/core/http';
-import {
-  InternalDtoMapper,
-  RequestDtoMapperConstructor,
-  ResponseDtoMapperConstructor,
-  transformIntoInternalDtoMapper
-} from '@forklaunch/core/mappers';
 import { PaymentLinkService } from '@forklaunch/interfaces-billing/interfaces';
 import {
-  CreatePaymentLinkDto,
-  PaymentLinkDto,
-  UpdatePaymentLinkDto
-} from '@forklaunch/interfaces-billing/types';
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
+import { BasePaymentLinkDtos } from '../types/baseBillingDto.types';
+import { BasePaymentLinkEntities } from '../types/baseBillingEntity.types';
 
 export class BasePaymentLinkService<
   SchemaValidator extends AnySchemaValidator,
+  PaymentMethodEnum,
   CurrencyEnum,
   StatusEnum,
-  Metrics extends MetricsDefinition = MetricsDefinition,
-  Dto extends {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum, StatusEnum>;
-    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum, StatusEnum>;
-  } = {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum, StatusEnum>;
-    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum, StatusEnum>;
-  },
-  Entities extends {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-  } = {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-  }
-> implements PaymentLinkService<CurrencyEnum, StatusEnum>
+  Entities extends BasePaymentLinkEntities<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >,
+  Dto extends BasePaymentLinkDtos<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  > = BasePaymentLinkDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum>
+> implements PaymentLinkService<PaymentMethodEnum, CurrencyEnum, StatusEnum>
 {
-  #mappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mappers>,
-    Entities,
-    Dto
-  >;
-  private evaluatedTelemetryOptions: {
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+  protected evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
     tracing?: boolean;
   };
-  private enableDatabaseBackup: boolean;
+  protected enableDatabaseBackup: boolean;
 
   constructor(
     protected readonly em: EntityManager,
     protected readonly cache: TtlCache,
-    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     protected readonly schemaValidator: SchemaValidator,
     protected readonly mappers: {
-      PaymentLinkDtoMapper: ResponseDtoMapperConstructor<
+      PaymentLinkMapper: ResponseMapperConstructor<
         SchemaValidator,
-        Dto['PaymentLinkDtoMapper'],
-        Entities['PaymentLinkDtoMapper']
+        Dto['PaymentLinkMapper'],
+        Entities['PaymentLinkMapper']
       >;
-      CreatePaymentLinkDtoMapper: RequestDtoMapperConstructor<
+      CreatePaymentLinkMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['CreatePaymentLinkDtoMapper'],
-        Entities['CreatePaymentLinkDtoMapper']
+        Dto['CreatePaymentLinkMapper'],
+        Entities['CreatePaymentLinkMapper'],
+        (
+          dto: Dto['CreatePaymentLinkMapper'],
+          em: EntityManager
+        ) => Promise<Entities['CreatePaymentLinkMapper']>
       >;
-      UpdatePaymentLinkDtoMapper: RequestDtoMapperConstructor<
+      UpdatePaymentLinkMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['UpdatePaymentLinkDtoMapper'],
-        Entities['UpdatePaymentLinkDtoMapper']
+        Dto['UpdatePaymentLinkMapper'],
+        Entities['UpdatePaymentLinkMapper'],
+        (
+          dto: Dto['UpdatePaymentLinkMapper'],
+          em: EntityManager
+        ) => Promise<Entities['UpdatePaymentLinkMapper']>
       >;
     },
     readonly options?: {
@@ -85,7 +78,7 @@ export class BasePaymentLinkService<
       telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
@@ -100,14 +93,14 @@ export class BasePaymentLinkService<
   protected createCacheKey = createCacheKey(this.cacheKeyPrefix);
 
   async createPaymentLink(
-    paymentLinkDto: Dto['CreatePaymentLinkDtoMapper']
-  ): Promise<Dto['PaymentLinkDtoMapper']> {
+    paymentLinkDto: Dto['CreatePaymentLinkMapper']
+  ): Promise<Dto['PaymentLinkMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating payment link', paymentLinkDto);
     }
 
     const paymentLink =
-      await this.#mappers.CreatePaymentLinkDtoMapper.deserializeDtoToEntity(
+      await this._mappers.CreatePaymentLinkMapper.deserializeDtoToEntity(
         paymentLinkDto,
         this.em
       );
@@ -117,9 +110,7 @@ export class BasePaymentLinkService<
     }
 
     const createdPaymentLinkDto =
-      await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
-        paymentLink
-      );
+      await this._mappers.PaymentLinkMapper.serializeEntityToDto(paymentLink);
 
     await this.cache.putRecord({
       key: this.createCacheKey(createdPaymentLinkDto.id),
@@ -131,21 +122,21 @@ export class BasePaymentLinkService<
   }
 
   async updatePaymentLink(
-    paymentLinkDto: Dto['UpdatePaymentLinkDtoMapper']
-  ): Promise<Dto['PaymentLinkDtoMapper']> {
+    paymentLinkDto: Dto['UpdatePaymentLinkMapper']
+  ): Promise<Dto['PaymentLinkMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating payment link', paymentLinkDto);
     }
 
     const cacheKey = this.createCacheKey(paymentLinkDto.id);
     const existingLink = (
-      await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(cacheKey)
+      await this.cache.readRecord<Entities['PaymentLinkMapper']>(cacheKey)
     )?.value;
     if (!existingLink) {
       throw new Error('Payment link not found');
     }
     const paymentLink =
-      await this.#mappers.UpdatePaymentLinkDtoMapper.deserializeDtoToEntity(
+      await this._mappers.UpdatePaymentLinkMapper.deserializeDtoToEntity(
         paymentLinkDto,
         this.em
       );
@@ -156,7 +147,7 @@ export class BasePaymentLinkService<
 
     const updatedLinkDto = {
       ...existingLink,
-      ...(await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+      ...(await this._mappers.PaymentLinkMapper.serializeEntityToDto(
         paymentLink
       ))
     };
@@ -170,18 +161,18 @@ export class BasePaymentLinkService<
     return updatedLinkDto;
   }
 
-  async getPaymentLink({ id }: IdDto): Promise<Dto['PaymentLinkDtoMapper']> {
+  async getPaymentLink({ id }: IdDto): Promise<Dto['PaymentLinkMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting payment link', { id });
     }
     const cacheKey = this.createCacheKey(id);
     const paymentLink =
-      await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(cacheKey);
+      await this.cache.readRecord<Entities['PaymentLinkMapper']>(cacheKey);
     if (!paymentLink) {
       throw new Error('Payment link not found');
     }
 
-    return this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+    return this._mappers.PaymentLinkMapper.serializeEntityToDto(
       paymentLink.value
     );
   }
@@ -223,9 +214,7 @@ export class BasePaymentLinkService<
     await this.cache.deleteRecord(this.createCacheKey(id));
   }
 
-  async listPaymentLinks(
-    idsDto?: IdsDto
-  ): Promise<Dto['PaymentLinkDtoMapper'][]> {
+  async listPaymentLinks(idsDto?: IdsDto): Promise<Dto['PaymentLinkMapper'][]> {
     const keys =
       idsDto?.ids.map((id) => this.createCacheKey(id)) ??
       (await this.cache.listKeys(this.cacheKeyPrefix));
@@ -233,9 +222,9 @@ export class BasePaymentLinkService<
     return Promise.all(
       keys.map(async (key) => {
         const paymentLink =
-          await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(key);
+          await this.cache.readRecord<Entities['PaymentLinkMapper']>(key);
         const paymentLinkDto =
-          this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+          this._mappers.PaymentLinkMapper.serializeEntityToDto(
             paymentLink.value
           );
         return paymentLinkDto;

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

@@ -5,83 +5,76 @@ import {
   OpenTelemetryCollector,
   TelemetryOptions
 } from '@forklaunch/core/http';
-import {
-  InternalDtoMapper,
-  RequestDtoMapperConstructor,
-  ResponseDtoMapperConstructor,
-  transformIntoInternalDtoMapper
-} from '@forklaunch/core/mappers';
 import { PlanService } from '@forklaunch/interfaces-billing/interfaces';
 import {
-  CreatePlanDto,
-  PlanDto,
-  UpdatePlanDto
-} from '@forklaunch/interfaces-billing/types';
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
+import { BasePlanDtos } from '../types/baseBillingDto.types';
+import { BasePlanEntities } from '../types/baseBillingEntity.types';
 
 export class BasePlanService<
   SchemaValidator extends AnySchemaValidator,
   PlanCadenceEnum,
+  CurrencyEnum,
   BillingProviderEnum,
-  Metrics extends MetricsDefinition = MetricsDefinition,
-  Dto extends {
-    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    CreatePlanDtoMapper: CreatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    UpdatePlanDtoMapper: UpdatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
-  } = {
-    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    CreatePlanDtoMapper: CreatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    UpdatePlanDtoMapper: UpdatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
-  },
-  Entities extends {
-    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    CreatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    UpdatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-  } = {
-    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    CreatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    UpdatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-  }
-> implements PlanService<PlanCadenceEnum, BillingProviderEnum>
+  Entities extends BasePlanEntities<
+    PlanCadenceEnum,
+    CurrencyEnum,
+    BillingProviderEnum
+  >,
+  Dto extends BasePlanDtos<
+    PlanCadenceEnum,
+    CurrencyEnum,
+    BillingProviderEnum
+  > = BasePlanDtos<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>
+> implements PlanService<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>
 {
-  #mappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mappers>,
-    Entities,
-    Dto
-  >;
-  private evaluatedTelemetryOptions: {
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+  protected evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
     tracing?: boolean;
   };
 
   constructor(
-    private em: EntityManager,
-    private readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
-    private readonly schemaValidator: SchemaValidator,
-    private readonly mappers: {
-      PlanDtoMapper: ResponseDtoMapperConstructor<
+    protected em: EntityManager,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    protected readonly schemaValidator: SchemaValidator,
+    protected readonly mappers: {
+      PlanMapper: ResponseMapperConstructor<
         SchemaValidator,
-        Dto['PlanDtoMapper'],
-        Entities['PlanDtoMapper']
+        Dto['PlanMapper'],
+        Entities['PlanMapper']
       >;
-      CreatePlanDtoMapper: RequestDtoMapperConstructor<
+      CreatePlanMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['CreatePlanDtoMapper'],
-        Entities['CreatePlanDtoMapper']
+        Dto['CreatePlanMapper'],
+        Entities['CreatePlanMapper'],
+        (
+          dto: Dto['CreatePlanMapper'],
+          em: EntityManager
+        ) => Promise<Entities['CreatePlanMapper']>
       >;
-      UpdatePlanDtoMapper: RequestDtoMapperConstructor<
+      UpdatePlanMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['UpdatePlanDtoMapper'],
-        Entities['UpdatePlanDtoMapper']
+        Dto['UpdatePlanMapper'],
+        Entities['UpdatePlanMapper'],
+        (
+          dto: Dto['UpdatePlanMapper'],
+          em: EntityManager
+        ) => Promise<Entities['UpdatePlanMapper']>
       >;
     },
     readonly options?: {
       telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
       : {
@@ -94,7 +87,7 @@ export class BasePlanService<
   async listPlans(
     idsDto?: IdsDto,
     em?: EntityManager
-  ): Promise<Dto['PlanDtoMapper'][]> {
+  ): Promise<Dto['PlanMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Listing plans', idsDto);
     }
@@ -104,51 +97,48 @@ export class BasePlanService<
           filters: idsDto?.ids ? { id: { $in: idsDto.ids } } : undefined
         })
       ).map((plan) =>
-        this.#mappers.PlanDtoMapper.serializeEntityToDto(
-          plan as Entities['PlanDtoMapper']
+        this._mappers.PlanMapper.serializeEntityToDto(
+          plan as Entities['PlanMapper']
         )
       )
     );
   }
 
   async createPlan(
-    planDto: Dto['CreatePlanDtoMapper'],
+    planDto: Dto['CreatePlanMapper'],
     em?: EntityManager
-  ): Promise<Dto['PlanDtoMapper']> {
+  ): Promise<Dto['PlanMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating plan', planDto);
     }
-    const plan = await this.#mappers.CreatePlanDtoMapper.deserializeDtoToEntity(
+    const plan = await this._mappers.CreatePlanMapper.deserializeDtoToEntity(
       planDto,
       em ?? this.em
     );
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(plan);
     });
-    return this.#mappers.PlanDtoMapper.serializeEntityToDto(plan);
+    return this._mappers.PlanMapper.serializeEntityToDto(plan);
   }
 
-  async getPlan(
-    idDto: IdDto,
-    em?: EntityManager
-  ): Promise<Dto['PlanDtoMapper']> {
+  async getPlan(idDto: IdDto, em?: EntityManager): Promise<Dto['PlanMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting plan', idDto);
     }
     const plan = await (em ?? this.em).findOneOrFail('Plan', idDto);
-    return this.#mappers.PlanDtoMapper.serializeEntityToDto(
-      plan as Entities['PlanDtoMapper']
+    return this._mappers.PlanMapper.serializeEntityToDto(
+      plan as Entities['PlanMapper']
     );
   }
 
   async updatePlan(
-    planDto: Dto['UpdatePlanDtoMapper'],
+    planDto: Dto['UpdatePlanMapper'],
     em?: EntityManager
-  ): Promise<Dto['PlanDtoMapper']> {
+  ): Promise<Dto['PlanMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating plan', planDto);
     }
-    const plan = await this.#mappers.UpdatePlanDtoMapper.deserializeDtoToEntity(
+    const plan = await this._mappers.UpdatePlanMapper.deserializeDtoToEntity(
       planDto,
       em ?? this.em
     );
@@ -157,7 +147,7 @@ export class BasePlanService<
       await innerEm.persist(plan);
     });
     const updatedPlanDto =
-      await this.#mappers.PlanDtoMapper.serializeEntityToDto(updatedPlan);
+      await this._mappers.PlanMapper.serializeEntityToDto(updatedPlan);
     return updatedPlanDto;
   }