@forklaunch/implementation-billing-base 0.3.2 → 0.3.3

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

@@ -5,76 +5,31 @@ import {
   OpenTelemetryCollector,
   TelemetryOptions
 } from '@forklaunch/core/http';
-import {
-  InternalDtoMapper,
-  RequestDtoMapperConstructor,
-  ResponseDtoMapperConstructor,
-  transformIntoInternalDtoMapper
-} from '@forklaunch/core/mappers';
 import { SubscriptionService } from '@forklaunch/interfaces-billing/interfaces';
 import {
-  CreateSubscriptionDto,
-  SubscriptionDto,
-  UpdateSubscriptionDto
-} from '@forklaunch/interfaces-billing/types';
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
+import { BaseSubscriptionDtos } from '../types/baseBillingDto.types';
+import { BaseSubscriptionEntities } from '../types/baseBillingEntity.types';
 
 export class BaseSubscriptionService<
   SchemaValidator extends AnySchemaValidator,
   PartyType,
   BillingProviderType,
-  Metrics extends MetricsDefinition = MetricsDefinition,
-  Dto extends {
-    SubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    CreateSubscriptionDtoMapper: CreateSubscriptionDto<
-      PartyType,
-      BillingProviderType
-    >;
-    UpdateSubscriptionDtoMapper: UpdateSubscriptionDto<
-      PartyType,
-      BillingProviderType
-    >;
-  } = {
-    SubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    CreateSubscriptionDtoMapper: CreateSubscriptionDto<
-      PartyType,
-      BillingProviderType
-    >;
-    UpdateSubscriptionDtoMapper: UpdateSubscriptionDto<
-      PartyType,
-      BillingProviderType
-    >;
-  },
-  Entities extends {
-    SubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    CreateSubscriptionDtoMapper: SubscriptionDto<
-      PartyType,
-      BillingProviderType
-    >;
-    UpdateSubscriptionDtoMapper: SubscriptionDto<
-      PartyType,
-      BillingProviderType
-    >;
-  } = {
-    SubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    CreateSubscriptionDtoMapper: SubscriptionDto<
-      PartyType,
-      BillingProviderType
-    >;
-    UpdateSubscriptionDtoMapper: SubscriptionDto<
-      PartyType,
-      BillingProviderType
-    >;
-  }
+  Entities extends BaseSubscriptionEntities<PartyType, BillingProviderType>,
+  Dto extends BaseSubscriptionDtos<
+    PartyType,
+    BillingProviderType
+  > = BaseSubscriptionDtos<PartyType, BillingProviderType>
 > implements SubscriptionService<PartyType, BillingProviderType>
 {
-  #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;
@@ -82,36 +37,38 @@ export class BaseSubscriptionService<
 
   constructor(
     protected em: EntityManager,
-    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     protected readonly schemaValidator: SchemaValidator,
     protected readonly mappers: {
-      SubscriptionDtoMapper: ResponseDtoMapperConstructor<
+      SubscriptionMapper: ResponseMapperConstructor<
         SchemaValidator,
-        Dto['SubscriptionDtoMapper'],
-        Entities['SubscriptionDtoMapper']
+        Dto['SubscriptionMapper'],
+        Entities['SubscriptionMapper']
       >;
-      CreateSubscriptionDtoMapper: RequestDtoMapperConstructor<
+      CreateSubscriptionMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['CreateSubscriptionDtoMapper'],
-        Entities['CreateSubscriptionDtoMapper']
+        Dto['CreateSubscriptionMapper'],
+        Entities['CreateSubscriptionMapper'],
+        (
+          dto: Dto['CreateSubscriptionMapper'],
+          em: EntityManager
+        ) => Promise<Entities['CreateSubscriptionMapper']>
       >;
-      UpdateSubscriptionDtoMapper: RequestDtoMapperConstructor<
+      UpdateSubscriptionMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['UpdateSubscriptionDtoMapper'],
-        Entities['UpdateSubscriptionDtoMapper']
+        Dto['UpdateSubscriptionMapper'],
+        Entities['UpdateSubscriptionMapper'],
+        (
+          dto: Dto['UpdateSubscriptionMapper'],
+          em: EntityManager
+        ) => Promise<Entities['UpdateSubscriptionMapper']>
       >;
     },
     readonly options?: {
-      enableDatabaseBackup?: boolean;
       telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mappers = transformIntoInternalDtoMapper<
-      SchemaValidator,
-      typeof this.mappers,
-      Entities,
-      Dto
-    >(mappers, this.schemaValidator);
+    this._mappers = transformIntoInternalMapper(mappers, this.schemaValidator);
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
       : {
@@ -122,9 +79,9 @@ export class BaseSubscriptionService<
   }
 
   async createSubscription(
-    subscriptionDto: Dto['CreateSubscriptionDtoMapper'],
+    subscriptionDto: Dto['CreateSubscriptionMapper'],
     em?: EntityManager
-  ): Promise<Dto['SubscriptionDtoMapper']> {
+  ): Promise<Dto['SubscriptionMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
         'Creating subscription',
@@ -132,7 +89,7 @@ export class BaseSubscriptionService<
       );
     }
     const subscription =
-      await this.#mappers.CreateSubscriptionDtoMapper.deserializeDtoToEntity(
+      await this._mappers.CreateSubscriptionMapper.deserializeDtoToEntity(
         subscriptionDto,
         em ?? this.em
       );
@@ -140,16 +97,14 @@ export class BaseSubscriptionService<
       await innerEm.persist(subscription);
     });
     const createdSubscriptionDto =
-      await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-        subscription
-      );
+      await this._mappers.SubscriptionMapper.serializeEntityToDto(subscription);
     return createdSubscriptionDto;
   }
 
   async getSubscription(
     idDto: IdDto,
     em?: EntityManager
-  ): Promise<Dto['SubscriptionDtoMapper']> {
+  ): Promise<Dto['SubscriptionMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting subscription', idDto);
     }
@@ -157,15 +112,15 @@ export class BaseSubscriptionService<
       'Subscription',
       idDto
     );
-    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-      subscription as Entities['SubscriptionDtoMapper']
+    return this._mappers.SubscriptionMapper.serializeEntityToDto(
+      subscription as Entities['SubscriptionMapper']
     );
   }
 
   async getUserSubscription(
     { id }: IdDto,
     em?: EntityManager
-  ): Promise<Dto['SubscriptionDtoMapper']> {
+  ): Promise<Dto['SubscriptionMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting user subscription', id);
     }
@@ -175,15 +130,15 @@ export class BaseSubscriptionService<
       active: true
     });
 
-    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-      subscription as Entities['SubscriptionDtoMapper']
+    return this._mappers.SubscriptionMapper.serializeEntityToDto(
+      subscription as Entities['SubscriptionMapper']
     );
   }
 
   async getOrganizationSubscription(
     { id }: IdDto,
     em?: EntityManager
-  ): Promise<Dto['SubscriptionDtoMapper']> {
+  ): Promise<Dto['SubscriptionMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting organization subscription', id);
     }
@@ -192,15 +147,15 @@ export class BaseSubscriptionService<
       partyType: 'ORGANIZATION',
       active: true
     });
-    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-      subscription as Entities['SubscriptionDtoMapper']
+    return this._mappers.SubscriptionMapper.serializeEntityToDto(
+      subscription as Entities['SubscriptionMapper']
     );
   }
 
   async updateSubscription(
-    subscriptionDto: Dto['UpdateSubscriptionDtoMapper'],
+    subscriptionDto: Dto['UpdateSubscriptionMapper'],
     em?: EntityManager
-  ): Promise<Dto['SubscriptionDtoMapper']> {
+  ): Promise<Dto['SubscriptionMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
         'Updating subscription',
@@ -208,7 +163,7 @@ export class BaseSubscriptionService<
       );
     }
     const subscription =
-      this.#mappers.UpdateSubscriptionDtoMapper.deserializeDtoToEntity(
+      this._mappers.UpdateSubscriptionMapper.deserializeDtoToEntity(
         subscriptionDto,
         em ?? this.em
       );
@@ -217,7 +172,7 @@ export class BaseSubscriptionService<
       await innerEm.persist(updatedSubscription);
     });
     const updatedSubscriptionDto =
-      await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      await this._mappers.SubscriptionMapper.serializeEntityToDto(
         updatedSubscription
       );
 
@@ -241,7 +196,7 @@ export class BaseSubscriptionService<
   async listSubscriptions(
     idsDto: { ids?: string[] },
     em?: EntityManager
-  ): Promise<Dto['SubscriptionDtoMapper'][]> {
+  ): Promise<Dto['SubscriptionMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Listing subscriptions', idsDto);
     }
@@ -258,8 +213,8 @@ export class BaseSubscriptionService<
     return Promise.all(
       subscriptions.map((subscription) => {
         const subscriptionDto =
-          this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-            subscription as Entities['SubscriptionDtoMapper']
+          this._mappers.SubscriptionMapper.serializeEntityToDto(
+            subscription as Entities['SubscriptionMapper']
           );
         return subscriptionDto;
       })
@@ -274,7 +229,7 @@ export class BaseSubscriptionService<
     if (!subscription) {
       throw new Error('Subscription not found');
     }
-    (subscription as Entities['SubscriptionDtoMapper']).active = false;
+    (subscription as Entities['SubscriptionMapper']).active = false;
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(subscription);
     });
@@ -288,7 +243,7 @@ export class BaseSubscriptionService<
     if (!subscription) {
       throw new Error('Subscription not found');
     }
-    (subscription as Entities['SubscriptionDtoMapper']).active = true;
+    (subscription as Entities['SubscriptionMapper']).active = true;
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(subscription);
     });

package/lib/eject/types/baseBillingDto.types.ts

@@ -0,0 +1,94 @@
+import {
+  BillingPortalDto,
+  CheckoutSessionDto,
+  CreateBillingPortalDto,
+  CreateCheckoutSessionDto,
+  CreatePaymentLinkDto,
+  CreatePlanDto,
+  CreateSubscriptionDto,
+  PaymentLinkDto,
+  PlanDto,
+  SubscriptionDto,
+  UpdateBillingPortalDto,
+  UpdateCheckoutSessionDto,
+  UpdatePaymentLinkDto,
+  UpdatePlanDto,
+  UpdateSubscriptionDto
+} from '@forklaunch/interfaces-billing/types';
+
+// billing dto types
+export type BaseBillingDtos = {
+  BillingPortalMapper: BillingPortalDto;
+  CreateBillingPortalMapper: CreateBillingPortalDto;
+  UpdateBillingPortalMapper: UpdateBillingPortalDto;
+};
+
+// checkout session dto types
+export type BaseCheckoutSessionDtos<
+  PaymentMethodEnum,
+  CurrencyEnum,
+  StatusEnum
+> = {
+  CheckoutSessionMapper: CheckoutSessionDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+  CreateCheckoutSessionMapper: CreateCheckoutSessionDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+  UpdateCheckoutSessionMapper: UpdateCheckoutSessionDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+};
+
+// payment link dto types
+export type BasePaymentLinkDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum> = {
+  PaymentLinkMapper: PaymentLinkDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+  CreatePaymentLinkMapper: CreatePaymentLinkDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+  UpdatePaymentLinkMapper: UpdatePaymentLinkDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+};
+
+// plan dto types
+export type BasePlanDtos<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum> = {
+  PlanMapper: PlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+  CreatePlanMapper: CreatePlanDto<
+    PlanCadenceEnum,
+    CurrencyEnum,
+    BillingProviderEnum
+  >;
+  UpdatePlanMapper: UpdatePlanDto<
+    PlanCadenceEnum,
+    CurrencyEnum,
+    BillingProviderEnum
+  >;
+};
+
+// subscription dto types
+export type BaseSubscriptionDtos<PartyType, BillingProviderType> = {
+  SubscriptionMapper: SubscriptionDto<PartyType, BillingProviderType>;
+  CreateSubscriptionMapper: CreateSubscriptionDto<
+    PartyType,
+    BillingProviderType
+  >;
+  UpdateSubscriptionMapper: UpdateSubscriptionDto<
+    PartyType,
+    BillingProviderType
+  >;
+};

package/lib/eject/types/baseBillingEntity.types.ts

@@ -0,0 +1,78 @@
+import {
+  BillingPortalDto,
+  CheckoutSessionDto,
+  PaymentLinkDto,
+  PlanDto,
+  SubscriptionDto
+} from '@forklaunch/interfaces-billing/types';
+
+// billing entity types
+export type BaseBillingEntities = {
+  BillingPortalMapper: BillingPortalDto;
+  CreateBillingPortalMapper: BillingPortalDto;
+  UpdateBillingPortalMapper: BillingPortalDto;
+};
+
+// checkout session entity types
+export type BaseCheckoutSessionEntities<
+  PaymentMethodEnum,
+  CurrencyEnum,
+  StatusEnum
+> = {
+  CheckoutSessionMapper: CheckoutSessionDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+  CreateCheckoutSessionMapper: CheckoutSessionDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+  UpdateCheckoutSessionMapper: CheckoutSessionDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+};
+
+// payment link entity types
+export type BasePaymentLinkEntities<
+  PaymentMethodEnum,
+  CurrencyEnum,
+  StatusEnum
+> = {
+  PaymentLinkMapper: PaymentLinkDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+  CreatePaymentLinkMapper: PaymentLinkDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+  UpdatePaymentLinkMapper: PaymentLinkDto<
+    PaymentMethodEnum,
+    CurrencyEnum,
+    StatusEnum
+  >;
+};
+
+// plan entity types
+export type BasePlanEntities<
+  PlanCadenceEnum,
+  CurrencyEnum,
+  BillingProviderEnum
+> = {
+  PlanMapper: PlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+  CreatePlanMapper: PlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+  UpdatePlanMapper: PlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+};
+
+// subscription entity types
+export type BaseSubscriptionEntities<PartyType, BillingProviderType> = {
+  SubscriptionMapper: SubscriptionDto<PartyType, BillingProviderType>;
+  CreateSubscriptionMapper: SubscriptionDto<PartyType, BillingProviderType>;
+  UpdateSubscriptionMapper: SubscriptionDto<PartyType, BillingProviderType>;
+};