@forklaunch/implementation-billing-base 0.5.8 → 0.6.1

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

@@ -1,4 +1,4 @@
-import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import { IdDto, IdsDto } from '@forklaunch/common';
 import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
 import {
   evaluateTelemetryOptions,
@@ -8,103 +8,65 @@ import {
 } from '@forklaunch/core/http';
 import { PaymentLinkService } from '@forklaunch/interfaces-billing/interfaces';
 import {
-  InternalMapper,
-  RequestMapperConstructor,
-  ResponseMapperConstructor,
-  transformIntoInternalMapper
-} from '@forklaunch/internal';
+  CreatePaymentLinkDto,
+  UpdatePaymentLinkDto
+} from '@forklaunch/interfaces-billing/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
 import { BasePaymentLinkDtos } from '../domain/types/baseBillingDto.types';
 import { BasePaymentLinkEntities } from '../domain/types/baseBillingEntity.types';
+import { PaymentLinkMappers } from '../domain/types/paymentLink.mapper.types';
 
 export class BasePaymentLinkService<
   SchemaValidator extends AnySchemaValidator,
   PaymentMethodEnum,
   CurrencyEnum,
   StatusEnum,
-  Entities extends BasePaymentLinkEntities<
+  MapperEntities extends BasePaymentLinkEntities<
     PaymentMethodEnum,
     CurrencyEnum,
     StatusEnum
   >,
-  Dto extends BasePaymentLinkDtos<
+  MapperDomains extends BasePaymentLinkDtos<
     PaymentMethodEnum,
     CurrencyEnum,
     StatusEnum
   > = BasePaymentLinkDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum>
 > implements PaymentLinkService<PaymentMethodEnum, CurrencyEnum, StatusEnum>
 {
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
-  protected evaluatedTelemetryOptions: {
+  private evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
     tracing?: boolean;
   };
   protected enableDatabaseBackup: boolean;
-  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
-      ) => Promise<Entities['CreatePaymentLinkMapper']>
-    >;
-    UpdatePaymentLinkMapper: RequestMapperConstructor<
-      SchemaValidator,
-      Dto['UpdatePaymentLinkMapper'],
-      Entities['UpdatePaymentLinkMapper'],
-      (
-        dto: Dto['UpdatePaymentLinkMapper'],
-        em: EntityManager
-      ) => Promise<Entities['UpdatePaymentLinkMapper']>
-    >;
-  };
+  public em: EntityManager;
+  protected cache: TtlCache;
+  protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+  protected schemaValidator: SchemaValidator;
+  protected mappers: PaymentLinkMappers<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum,
+    MapperEntities,
+    MapperDomains
+  >;
 
   constructor(
     em: EntityManager,
     cache: TtlCache,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     schemaValidator: SchemaValidator,
-    mappers: {
-      PaymentLinkMapper: ResponseMapperConstructor<
-        SchemaValidator,
-        Dto['PaymentLinkMapper'],
-        Entities['PaymentLinkMapper']
-      >;
-      CreatePaymentLinkMapper: RequestMapperConstructor<
-        SchemaValidator,
-        Dto['CreatePaymentLinkMapper'],
-        Entities['CreatePaymentLinkMapper'],
-        (
-          dto: Dto['CreatePaymentLinkMapper'],
-          em: EntityManager
-        ) => Promise<Entities['CreatePaymentLinkMapper']>
-      >;
-      UpdatePaymentLinkMapper: RequestMapperConstructor<
-        SchemaValidator,
-        Dto['UpdatePaymentLinkMapper'],
-        Entities['UpdatePaymentLinkMapper'],
-        (
-          dto: Dto['UpdatePaymentLinkMapper'],
-          em: EntityManager
-        ) => Promise<Entities['UpdatePaymentLinkMapper']>
-      >;
-    },
-    readonly options?: {
-      enableDatabaseBackup?: boolean;
+    mappers: PaymentLinkMappers<
+      PaymentMethodEnum,
+      CurrencyEnum,
+      StatusEnum,
+      MapperEntities,
+      MapperDomains
+    >,
+    options?: {
       telemetry?: TelemetryOptions;
+      enableDatabaseBackup?: boolean;
     }
   ) {
     this.em = em;
@@ -112,7 +74,6 @@ export class BasePaymentLinkService<
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
@@ -127,24 +88,29 @@ export class BasePaymentLinkService<
   protected createCacheKey = createCacheKey(this.cacheKeyPrefix);
 
   async createPaymentLink(
-    paymentLinkDto: Dto['CreatePaymentLinkMapper']
-  ): Promise<Dto['PaymentLinkMapper']> {
+    paymentLinkDto: CreatePaymentLinkDto<
+      PaymentMethodEnum,
+      CurrencyEnum,
+      StatusEnum
+    >,
+    ...args: unknown[]
+  ): Promise<MapperDomains['PaymentLinkMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating payment link', paymentLinkDto);
     }
 
-    const paymentLink =
-      await this._mappers.CreatePaymentLinkMapper.deserializeDtoToEntity(
-        paymentLinkDto,
-        this.em
-      );
+    const paymentLink = await this.mappers.CreatePaymentLinkMapper.toEntity(
+      paymentLinkDto,
+      this.em,
+      ...args
+    );
 
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(paymentLink);
     }
 
     const createdPaymentLinkDto =
-      await this._mappers.PaymentLinkMapper.serializeEntityToDto(paymentLink);
+      await this.mappers.PaymentLinkMapper.toDto(paymentLink);
 
     await this.cache.putRecord({
       key: this.createCacheKey(createdPaymentLinkDto.id),
@@ -156,24 +122,29 @@ export class BasePaymentLinkService<
   }
 
   async updatePaymentLink(
-    paymentLinkDto: Dto['UpdatePaymentLinkMapper']
-  ): Promise<Dto['PaymentLinkMapper']> {
+    paymentLinkDto: UpdatePaymentLinkDto<
+      PaymentMethodEnum,
+      CurrencyEnum,
+      StatusEnum
+    >,
+    ...args: unknown[]
+  ): Promise<MapperDomains['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['PaymentLinkMapper']>(cacheKey)
+      await this.cache.readRecord<MapperEntities['PaymentLinkMapper']>(cacheKey)
     )?.value;
     if (!existingLink) {
       throw new Error('Payment link not found');
     }
-    const paymentLink =
-      await this._mappers.UpdatePaymentLinkMapper.deserializeDtoToEntity(
-        paymentLinkDto,
-        this.em
-      );
+    const paymentLink = await this.mappers.UpdatePaymentLinkMapper.toEntity(
+      paymentLinkDto,
+      this.em,
+      ...args
+    );
 
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(paymentLink);
@@ -181,9 +152,7 @@ export class BasePaymentLinkService<
 
     const updatedLinkDto = {
       ...existingLink,
-      ...(await this._mappers.PaymentLinkMapper.serializeEntityToDto(
-        paymentLink
-      ))
+      ...(await this.mappers.PaymentLinkMapper.toDto(paymentLink))
     };
 
     await this.cache.putRecord({
@@ -195,20 +164,22 @@ export class BasePaymentLinkService<
     return updatedLinkDto;
   }
 
-  async getPaymentLink({ id }: IdDto): Promise<Dto['PaymentLinkMapper']> {
+  async getPaymentLink({
+    id
+  }: IdDto): Promise<MapperDomains['PaymentLinkMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting payment link', { id });
     }
     const cacheKey = this.createCacheKey(id);
     const paymentLink =
-      await this.cache.readRecord<Entities['PaymentLinkMapper']>(cacheKey);
+      await this.cache.readRecord<MapperEntities['PaymentLinkMapper']>(
+        cacheKey
+      );
     if (!paymentLink) {
       throw new Error('Payment link not found');
     }
 
-    return this._mappers.PaymentLinkMapper.serializeEntityToDto(
-      paymentLink.value
-    );
+    return this.mappers.PaymentLinkMapper.toDto(paymentLink.value);
   }
 
   async expirePaymentLink({ id }: IdDto): Promise<void> {
@@ -248,7 +219,9 @@ export class BasePaymentLinkService<
     await this.cache.deleteRecord(this.createCacheKey(id));
   }
 
-  async listPaymentLinks(idsDto?: IdsDto): Promise<Dto['PaymentLinkMapper'][]> {
+  async listPaymentLinks(
+    idsDto?: IdsDto
+  ): Promise<MapperDomains['PaymentLinkMapper'][]> {
     const keys =
       idsDto?.ids.map((id) => this.createCacheKey(id)) ??
       (await this.cache.listKeys(this.cacheKeyPrefix));
@@ -256,11 +229,10 @@ export class BasePaymentLinkService<
     return Promise.all(
       keys.map(async (key) => {
         const paymentLink =
-          await this.cache.readRecord<Entities['PaymentLinkMapper']>(key);
-        const paymentLinkDto =
-          this._mappers.PaymentLinkMapper.serializeEntityToDto(
-            paymentLink.value
-          );
+          await this.cache.readRecord<MapperEntities['PaymentLinkMapper']>(key);
+        const paymentLinkDto = this.mappers.PaymentLinkMapper.toDto(
+          paymentLink.value
+        );
         return paymentLinkDto;
       })
     );

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

@@ -1,4 +1,4 @@
-import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import { IdDto, IdsDto } from '@forklaunch/common';
 import {
   evaluateTelemetryOptions,
   MetricsDefinition,
@@ -7,98 +7,60 @@ import {
 } from '@forklaunch/core/http';
 import { PlanService } from '@forklaunch/interfaces-billing/interfaces';
 import {
-  InternalMapper,
-  RequestMapperConstructor,
-  ResponseMapperConstructor,
-  transformIntoInternalMapper
-} from '@forklaunch/internal';
+  CreatePlanDto,
+  UpdatePlanDto
+} from '@forklaunch/interfaces-billing/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
 import { BasePlanDtos } from '../domain/types/baseBillingDto.types';
 import { BasePlanEntities } from '../domain/types/baseBillingEntity.types';
+import { PlanMappers } from '../domain/types/plan.mapper.types';
 
 export class BasePlanService<
   SchemaValidator extends AnySchemaValidator,
   PlanCadenceEnum,
   CurrencyEnum,
   BillingProviderEnum,
-  Entities extends BasePlanEntities<
+  MapperEntities extends BasePlanEntities<
     PlanCadenceEnum,
     CurrencyEnum,
     BillingProviderEnum
   >,
-  Dto extends BasePlanDtos<
+  MapperDomains extends BasePlanDtos<
     PlanCadenceEnum,
     CurrencyEnum,
     BillingProviderEnum
   > = BasePlanDtos<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>
 > implements PlanService<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>
 {
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
-  protected evaluatedTelemetryOptions: {
+  private evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
     tracing?: boolean;
   };
-  protected em: EntityManager;
-  protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
-  protected readonly schemaValidator: SchemaValidator;
-  protected readonly mappers: {
-    PlanMapper: ResponseMapperConstructor<
-      SchemaValidator,
-      Dto['PlanMapper'],
-      Entities['PlanMapper']
-    >;
-    CreatePlanMapper: RequestMapperConstructor<
-      SchemaValidator,
-      Dto['CreatePlanMapper'],
-      Entities['CreatePlanMapper'],
-      (
-        dto: Dto['CreatePlanMapper'],
-        em: EntityManager
-      ) => Promise<Entities['CreatePlanMapper']>
-    >;
-    UpdatePlanMapper: RequestMapperConstructor<
-      SchemaValidator,
-      Dto['UpdatePlanMapper'],
-      Entities['UpdatePlanMapper'],
-      (
-        dto: Dto['UpdatePlanMapper'],
-        em: EntityManager
-      ) => Promise<Entities['UpdatePlanMapper']>
-    >;
-  };
+  public em: EntityManager;
+  protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+  protected schemaValidator: SchemaValidator;
+  protected mappers: PlanMappers<
+    PlanCadenceEnum,
+    CurrencyEnum,
+    BillingProviderEnum,
+    MapperEntities,
+    MapperDomains
+  >;
 
   constructor(
     em: EntityManager,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     schemaValidator: SchemaValidator,
-    mappers: {
-      PlanMapper: ResponseMapperConstructor<
-        SchemaValidator,
-        Dto['PlanMapper'],
-        Entities['PlanMapper']
-      >;
-      CreatePlanMapper: RequestMapperConstructor<
-        SchemaValidator,
-        Dto['CreatePlanMapper'],
-        Entities['CreatePlanMapper'],
-        (
-          dto: Dto['CreatePlanMapper'],
-          em: EntityManager
-        ) => Promise<Entities['CreatePlanMapper']>
-      >;
-      UpdatePlanMapper: RequestMapperConstructor<
-        SchemaValidator,
-        Dto['UpdatePlanMapper'],
-        Entities['UpdatePlanMapper'],
-        (
-          dto: Dto['UpdatePlanMapper'],
-          em: EntityManager
-        ) => Promise<Entities['UpdatePlanMapper']>
-      >;
-    },
-    readonly options?: {
+    mappers: PlanMappers<
+      PlanCadenceEnum,
+      CurrencyEnum,
+      BillingProviderEnum,
+      MapperEntities,
+      MapperDomains
+    >,
+    options?: {
       telemetry?: TelemetryOptions;
     }
   ) {
@@ -106,7 +68,6 @@ export class BasePlanService<
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
       : {
@@ -119,7 +80,7 @@ export class BasePlanService<
   async listPlans(
     idsDto?: IdsDto,
     em?: EntityManager
-  ): Promise<Dto['PlanMapper'][]> {
+  ): Promise<MapperDomains['PlanMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Listing plans', idsDto);
     }
@@ -129,57 +90,59 @@ export class BasePlanService<
           filters: idsDto?.ids ? { id: { $in: idsDto.ids } } : undefined
         })
       ).map((plan) =>
-        this._mappers.PlanMapper.serializeEntityToDto(
-          plan as Entities['PlanMapper']
-        )
+        this.mappers.PlanMapper.toDto(plan as MapperEntities['PlanMapper'])
       )
     );
   }
 
   async createPlan(
-    planDto: Dto['CreatePlanMapper'],
-    em?: EntityManager
-  ): Promise<Dto['PlanMapper']> {
+    planDto: CreatePlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['PlanMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating plan', planDto);
     }
-    const plan = await this._mappers.CreatePlanMapper.deserializeDtoToEntity(
+    const plan = await this.mappers.CreatePlanMapper.toEntity(
       planDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(plan);
     });
-    return this._mappers.PlanMapper.serializeEntityToDto(plan);
+    return this.mappers.PlanMapper.toDto(plan);
   }
 
-  async getPlan(idDto: IdDto, em?: EntityManager): Promise<Dto['PlanMapper']> {
+  async getPlan(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['PlanMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting plan', idDto);
     }
     const plan = await (em ?? this.em).findOneOrFail('Plan', idDto);
-    return this._mappers.PlanMapper.serializeEntityToDto(
-      plan as Entities['PlanMapper']
-    );
+    return this.mappers.PlanMapper.toDto(plan as MapperEntities['PlanMapper']);
   }
 
   async updatePlan(
-    planDto: Dto['UpdatePlanMapper'],
-    em?: EntityManager
-  ): Promise<Dto['PlanMapper']> {
+    planDto: UpdatePlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['PlanMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating plan', planDto);
     }
-    const plan = await this._mappers.UpdatePlanMapper.deserializeDtoToEntity(
+    const plan = await this.mappers.UpdatePlanMapper.toEntity(
       planDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
     const updatedPlan = await (em ?? this.em).upsert(plan);
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(plan);
     });
-    const updatedPlanDto =
-      await this._mappers.PlanMapper.serializeEntityToDto(updatedPlan);
+    const updatedPlanDto = await this.mappers.PlanMapper.toDto(updatedPlan);
     return updatedPlanDto;
   }