@forklaunch/implementation-billing-base 0.5.8 → 0.6.0

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

@@ -0,0 +1,39 @@
+import { EntityManager } from '@mikro-orm/core';
+import { BaseCheckoutSessionDtos } from './baseBillingDto.types';
+import { BaseCheckoutSessionEntities } from './baseBillingEntity.types';
+
+export type CheckoutSessionMappers<
+  PaymentMethodEnum,
+  CurrencyEnum,
+  StatusEnum,
+  MapperEntities extends BaseCheckoutSessionEntities<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >,
+  MapperDomains extends BaseCheckoutSessionDtos<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >
+> = {
+  CheckoutSessionMapper: {
+    toDto: (
+      entity: MapperEntities['CheckoutSessionMapper']
+    ) => Promise<MapperDomains['CheckoutSessionMapper']>;
+  };
+  CreateCheckoutSessionMapper: {
+    toEntity: (
+      dto: MapperDomains['CreateCheckoutSessionMapper'],
+      em: EntityManager,
+      ...args: unknown[]
+    ) => Promise<MapperEntities['CreateCheckoutSessionMapper']>;
+  };
+  UpdateCheckoutSessionMapper: {
+    toEntity: (
+      dto: MapperDomains['UpdateCheckoutSessionMapper'],
+      em: EntityManager,
+      ...args: unknown[]
+    ) => Promise<MapperEntities['UpdateCheckoutSessionMapper']>;
+  };
+};

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

@@ -0,0 +1,7 @@
+export * from './baseBillingDto.types';
+export * from './baseBillingEntity.types';
+export * from './billingPortal.mapper.types';
+export * from './checkoutSession.mapper.types';
+export * from './paymentLink.mapper.types';
+export * from './plan.mapper.types';
+export * from './subscription.mapper.types';

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

@@ -0,0 +1,39 @@
+import { EntityManager } from '@mikro-orm/core';
+import { BasePaymentLinkDtos } from './baseBillingDto.types';
+import { BasePaymentLinkEntities } from './baseBillingEntity.types';
+
+export type PaymentLinkMappers<
+  PaymentMethodEnum,
+  CurrencyEnum,
+  StatusEnum,
+  MapperEntities extends BasePaymentLinkEntities<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >,
+  MapperDomains extends BasePaymentLinkDtos<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >
+> = {
+  PaymentLinkMapper: {
+    toDto: (
+      entity: MapperEntities['PaymentLinkMapper']
+    ) => Promise<MapperDomains['PaymentLinkMapper']>;
+  };
+  CreatePaymentLinkMapper: {
+    toEntity: (
+      dto: MapperDomains['CreatePaymentLinkMapper'],
+      em: EntityManager,
+      ...args: unknown[]
+    ) => Promise<MapperEntities['CreatePaymentLinkMapper']>;
+  };
+  UpdatePaymentLinkMapper: {
+    toEntity: (
+      dto: MapperDomains['UpdatePaymentLinkMapper'],
+      em: EntityManager,
+      ...args: unknown[]
+    ) => Promise<MapperEntities['UpdatePaymentLinkMapper']>;
+  };
+};

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

@@ -0,0 +1,39 @@
+import { EntityManager } from '@mikro-orm/core';
+import { BasePlanDtos } from './baseBillingDto.types';
+import { BasePlanEntities } from './baseBillingEntity.types';
+
+export type PlanMappers<
+  PlanCadenceEnum,
+  CurrencyEnum,
+  BillingProviderEnum,
+  MapperEntities extends BasePlanEntities<
+    PlanCadenceEnum,
+    CurrencyEnum,
+    BillingProviderEnum
+  >,
+  MapperDomains extends BasePlanDtos<
+    PlanCadenceEnum,
+    CurrencyEnum,
+    BillingProviderEnum
+  >
+> = {
+  PlanMapper: {
+    toDto: (
+      entity: MapperEntities['PlanMapper']
+    ) => Promise<MapperDomains['PlanMapper']>;
+  };
+  CreatePlanMapper: {
+    toEntity: (
+      dto: MapperDomains['CreatePlanMapper'],
+      em: EntityManager,
+      ...args: unknown[]
+    ) => Promise<MapperEntities['CreatePlanMapper']>;
+  };
+  UpdatePlanMapper: {
+    toEntity: (
+      dto: MapperDomains['UpdatePlanMapper'],
+      em: EntityManager,
+      ...args: unknown[]
+    ) => Promise<MapperEntities['UpdatePlanMapper']>;
+  };
+};

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

@@ -0,0 +1,33 @@
+import { EntityManager } from '@mikro-orm/core';
+import { BaseSubscriptionDtos } from './baseBillingDto.types';
+import { BaseSubscriptionEntities } from './baseBillingEntity.types';
+
+export type SubscriptionMappers<
+  PartyType,
+  BillingProviderType,
+  MapperEntities extends BaseSubscriptionEntities<
+    PartyType,
+    BillingProviderType
+  >,
+  MapperDomains extends BaseSubscriptionDtos<PartyType, BillingProviderType>
+> = {
+  SubscriptionMapper: {
+    toDto: (
+      entity: MapperEntities['SubscriptionMapper']
+    ) => Promise<MapperDomains['SubscriptionMapper']>;
+  };
+  CreateSubscriptionMapper: {
+    toEntity: (
+      dto: MapperDomains['CreateSubscriptionMapper'],
+      em: EntityManager,
+      ...args: unknown[]
+    ) => Promise<MapperEntities['CreateSubscriptionMapper']>;
+  };
+  UpdateSubscriptionMapper: {
+    toEntity: (
+      dto: MapperDomains['UpdateSubscriptionMapper'],
+      em: EntityManager,
+      ...args: unknown[]
+    ) => Promise<MapperEntities['UpdateSubscriptionMapper']>;
+  };
+};

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

@@ -1,4 +1,4 @@
-import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { IdDto } from '@forklaunch/common';
 import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
 import {
   evaluateTelemetryOptions,
@@ -7,92 +7,41 @@ import {
   TelemetryOptions
 } from '@forklaunch/core/http';
 import { BillingPortalService } from '@forklaunch/interfaces-billing/interfaces';
-import { UpdateBillingPortalDto } from '@forklaunch/interfaces-billing/types';
 import {
-  InternalMapper,
-  RequestMapperConstructor,
-  ResponseMapperConstructor,
-  transformIntoInternalMapper
-} from '@forklaunch/internal';
+  CreateBillingPortalDto,
+  UpdateBillingPortalDto
+} from '@forklaunch/interfaces-billing/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
 import { BaseBillingDtos } from '../domain/types/baseBillingDto.types';
 import { BaseBillingEntities } from '../domain/types/baseBillingEntity.types';
+import { BillingPortalMappers } from '../domain/types/billingPortal.mapper.types';
 
 export class BaseBillingPortalService<
   SchemaValidator extends AnySchemaValidator,
-  Entities extends BaseBillingEntities,
-  Dto extends BaseBillingDtos = BaseBillingDtos
+  MapperEntities extends BaseBillingEntities,
+  MapperDomains extends BaseBillingDtos = BaseBillingDtos
 > implements BillingPortalService
 {
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
-  protected evaluatedTelemetryOptions: {
+  private evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
     tracing?: boolean;
   };
   protected enableDatabaseBackup: boolean;
-  protected em: EntityManager;
+  public 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
-      ) => Promise<Entities['CreateBillingPortalMapper']>
-    >;
-    UpdateBillingPortalMapper: RequestMapperConstructor<
-      SchemaValidator,
-      Dto['UpdateBillingPortalMapper'],
-      Entities['UpdateBillingPortalMapper'],
-      (
-        dto: Dto['UpdateBillingPortalMapper'],
-        em: EntityManager
-      ) => Promise<Entities['UpdateBillingPortalMapper']>
-    >;
-  };
+  protected mappers: BillingPortalMappers<MapperEntities, MapperDomains>;
 
   constructor(
     em: EntityManager,
     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
-        ) => Promise<Entities['CreateBillingPortalMapper']>
-      >;
-      UpdateBillingPortalMapper: RequestMapperConstructor<
-        SchemaValidator,
-        Dto['UpdateBillingPortalMapper'],
-        Entities['UpdateBillingPortalMapper'],
-        (
-          dto: Dto['UpdateBillingPortalMapper'],
-          em: EntityManager
-        ) => Promise<Entities['UpdateBillingPortalMapper']>
-      >;
-    },
-    readonly options?: {
+    mappers: BillingPortalMappers<MapperEntities, MapperDomains>,
+    options?: {
       telemetry?: TelemetryOptions;
       enableDatabaseBackup?: boolean;
     }
@@ -102,7 +51,6 @@ export class BaseBillingPortalService<
     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
@@ -116,8 +64,9 @@ export class BaseBillingPortalService<
   protected createCacheKey = createCacheKey('billing_portal_session');
 
   async createBillingPortalSession(
-    billingPortalDto: Dto['CreateBillingPortalMapper']
-  ): Promise<Dto['BillingPortalMapper']> {
+    billingPortalDto: CreateBillingPortalDto,
+    ...args: unknown[]
+  ): Promise<MapperDomains['BillingPortalMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
         'Creating billing portal session',
@@ -125,20 +74,18 @@ export class BaseBillingPortalService<
       );
     }
 
-    const billingPortal =
-      await this._mappers.CreateBillingPortalMapper.deserializeDtoToEntity(
-        billingPortalDto,
-        this.em
-      );
+    const billingPortal = await this.mappers.CreateBillingPortalMapper.toEntity(
+      billingPortalDto,
+      this.em,
+      ...args
+    );
 
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(billingPortal);
     }
 
     const createdBillingPortalDto =
-      await this._mappers.BillingPortalMapper.serializeEntityToDto(
-        billingPortal
-      );
+      await this.mappers.BillingPortalMapper.toDto(billingPortal);
 
     await this.cache.putRecord({
       key: this.createCacheKey(createdBillingPortalDto.id),
@@ -151,13 +98,13 @@ export class BaseBillingPortalService<
 
   async getBillingPortalSession(
     idDto: IdDto
-  ): Promise<Dto['BillingPortalMapper']> {
+  ): Promise<MapperDomains['BillingPortalMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting billing portal session', idDto);
     }
 
     const billingPortalDetails = await this.cache.readRecord<
-      Entities['BillingPortalMapper']
+      MapperEntities['BillingPortalMapper']
     >(this.createCacheKey(idDto.id));
 
     if (!billingPortalDetails) {
@@ -168,8 +115,9 @@ export class BaseBillingPortalService<
   }
 
   async updateBillingPortalSession(
-    billingPortalDto: UpdateBillingPortalDto
-  ): Promise<Dto['BillingPortalMapper']> {
+    billingPortalDto: UpdateBillingPortalDto,
+    ...args: unknown[]
+  ): Promise<MapperDomains['BillingPortalMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
         'Updating billing portal session',
@@ -178,7 +126,7 @@ export class BaseBillingPortalService<
     }
 
     const existingBillingPortal = (
-      await this.cache.readRecord<Entities['BillingPortalMapper']>(
+      await this.cache.readRecord<MapperEntities['BillingPortalMapper']>(
         this.createCacheKey(billingPortalDto.id)
       )
     )?.value;
@@ -187,11 +135,11 @@ export class BaseBillingPortalService<
       throw new Error('Session not found');
     }
 
-    const billingPortal =
-      await this._mappers.UpdateBillingPortalMapper.deserializeDtoToEntity(
-        billingPortalDto,
-        this.em
-      );
+    const billingPortal = await this.mappers.UpdateBillingPortalMapper.toEntity(
+      billingPortalDto,
+      this.em,
+      ...args
+    );
 
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush({
@@ -201,9 +149,7 @@ export class BaseBillingPortalService<
 
     const updatedBillingPortalDto = {
       ...existingBillingPortal,
-      ...(await this._mappers.BillingPortalMapper.serializeEntityToDto(
-        billingPortal
-      ))
+      ...(await this.mappers.BillingPortalMapper.toDto(billingPortal))
     };
 
     await this.cache.putRecord({

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

@@ -1,4 +1,4 @@
-import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { IdDto } from '@forklaunch/common';
 import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
 import {
   evaluateTelemetryOptions,
@@ -7,104 +7,63 @@ import {
   TelemetryOptions
 } from '@forklaunch/core/http';
 import { CheckoutSessionService } from '@forklaunch/interfaces-billing/interfaces';
-import {
-  InternalMapper,
-  RequestMapperConstructor,
-  ResponseMapperConstructor,
-  transformIntoInternalMapper
-} from '@forklaunch/internal';
+import { CreateCheckoutSessionDto } from '@forklaunch/interfaces-billing/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
 import { BaseCheckoutSessionDtos } from '../domain/types/baseBillingDto.types';
 import { BaseCheckoutSessionEntities } from '../domain/types/baseBillingEntity.types';
+import { CheckoutSessionMappers } from '../domain/types/checkoutSession.mapper.types';
 
 export class BaseCheckoutSessionService<
   SchemaValidator extends AnySchemaValidator,
   PaymentMethodEnum,
   CurrencyEnum,
   StatusEnum,
-  Entities extends BaseCheckoutSessionEntities<
+  MapperEntities extends BaseCheckoutSessionEntities<
     PaymentMethodEnum,
     CurrencyEnum,
     StatusEnum
   >,
-  Dto extends BaseCheckoutSessionDtos<
+  MapperDomains extends BaseCheckoutSessionDtos<
     PaymentMethodEnum,
     CurrencyEnum,
     StatusEnum
   > = BaseCheckoutSessionDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum>
 > implements CheckoutSessionService<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: {
-    CheckoutSessionMapper: ResponseMapperConstructor<
-      SchemaValidator,
-      Dto['CheckoutSessionMapper'],
-      Entities['CheckoutSessionMapper']
-    >;
-    CreateCheckoutSessionMapper: RequestMapperConstructor<
-      SchemaValidator,
-      Dto['CreateCheckoutSessionMapper'],
-      Entities['CreateCheckoutSessionMapper'],
-      (
-        dto: Dto['CreateCheckoutSessionMapper'],
-        em: EntityManager
-      ) => Promise<Entities['CreateCheckoutSessionMapper']>
-    >;
-    UpdateCheckoutSessionMapper: RequestMapperConstructor<
-      SchemaValidator,
-      Dto['UpdateCheckoutSessionMapper'],
-      Entities['UpdateCheckoutSessionMapper'],
-      (
-        dto: Dto['UpdateCheckoutSessionMapper'],
-        em: EntityManager
-      ) => Promise<Entities['UpdateCheckoutSessionMapper']>
-    >;
-  };
+  public em: EntityManager;
+  protected cache: TtlCache;
+  protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+  protected schemaValidator: SchemaValidator;
+  protected mappers: CheckoutSessionMappers<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum,
+    MapperEntities,
+    MapperDomains
+  >;
 
   constructor(
     em: EntityManager,
     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
-        ) => Promise<Entities['CreateCheckoutSessionMapper']>
-      >;
-      UpdateCheckoutSessionMapper: RequestMapperConstructor<
-        SchemaValidator,
-        Dto['UpdateCheckoutSessionMapper'],
-        Entities['UpdateCheckoutSessionMapper'],
-        (
-          dto: Dto['UpdateCheckoutSessionMapper'],
-          em: EntityManager
-        ) => Promise<Entities['UpdateCheckoutSessionMapper']>
-      >;
-    },
-    readonly options?: {
-      enableDatabaseBackup?: boolean;
+    mappers: CheckoutSessionMappers<
+      PaymentMethodEnum,
+      CurrencyEnum,
+      StatusEnum,
+      MapperEntities,
+      MapperDomains
+    >,
+    options?: {
       telemetry?: TelemetryOptions;
+      enableDatabaseBackup?: boolean;
     }
   ) {
     this.em = em;
@@ -112,7 +71,6 @@ export class BaseCheckoutSessionService<
     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
@@ -126,8 +84,13 @@ export class BaseCheckoutSessionService<
   protected createCacheKey = createCacheKey('checkout_session');
 
   async createCheckoutSession(
-    checkoutSessionDto: Dto['CreateCheckoutSessionMapper']
-  ): Promise<Dto['CheckoutSessionMapper']> {
+    checkoutSessionDto: CreateCheckoutSessionDto<
+      PaymentMethodEnum,
+      CurrencyEnum,
+      StatusEnum
+    >,
+    ...args: unknown[]
+  ): Promise<MapperDomains['CheckoutSessionMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
         'Creating checkout session',
@@ -136,15 +99,14 @@ export class BaseCheckoutSessionService<
     }
 
     const checkoutSession =
-      await this._mappers.CreateCheckoutSessionMapper.deserializeDtoToEntity(
+      await this.mappers.CreateCheckoutSessionMapper.toEntity(
         checkoutSessionDto,
-        this.em
+        this.em,
+        ...args
       );
 
     const createdCheckoutSessionDto =
-      await this._mappers.CheckoutSessionMapper.serializeEntityToDto(
-        checkoutSession
-      );
+      await this.mappers.CheckoutSessionMapper.toDto(checkoutSession);
 
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(checkoutSession);
@@ -161,15 +123,15 @@ export class BaseCheckoutSessionService<
 
   async getCheckoutSession({
     id
-  }: IdDto): Promise<Dto['CheckoutSessionMapper']> {
+  }: IdDto): Promise<MapperDomains['CheckoutSessionMapper']> {
     const checkoutSessionDetails = await this.cache.readRecord<
-      Entities['CheckoutSessionMapper']
+      MapperEntities['CheckoutSessionMapper']
     >(this.createCacheKey(id));
     if (!checkoutSessionDetails) {
       throw new Error('Session not found');
     }
 
-    return this._mappers.CheckoutSessionMapper.serializeEntityToDto(
+    return this.mappers.CheckoutSessionMapper.toDto(
       checkoutSessionDetails.value
     );
   }