@forklaunch/implementation-billing-stripe 0.0.1

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

@@ -0,0 +1,219 @@
+import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
+import { BasePlanService } from '@forklaunch/implementation-billing-base/services';
+import { PlanService } 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 { BillingProviderEnum } from '../domain/enums/billingProvider.enum';
+import { CurrencyEnum } from '../domain/enums/currency.enum';
+import { PlanCadenceEnum } from '../domain/enums/planCadence.enum';
+import {
+  StripeCreatePlanDto,
+  StripePlanDto,
+  StripePlanDtos,
+  StripeUpdatePlanDto
+} from '../types/stripe.dto.types';
+import { StripePlanEntities } from '../types/stripe.entity.types';
+
+export class StripePlanService<
+  SchemaValidator extends AnySchemaValidator,
+  Entities extends StripePlanEntities,
+  Dto extends StripePlanDtos = StripePlanDtos
+> implements
+    PlanService<
+      typeof PlanCadenceEnum,
+      typeof CurrencyEnum,
+      typeof BillingProviderEnum,
+      {
+        CreatePlanDto: StripeCreatePlanDto;
+        UpdatePlanDto: StripeUpdatePlanDto;
+        PlanDto: StripePlanDto;
+        IdDto: IdDto;
+        IdsDto: IdsDto;
+      }
+    >
+{
+  basePlanService: BasePlanService<
+    SchemaValidator,
+    typeof PlanCadenceEnum,
+    typeof CurrencyEnum,
+    typeof BillingProviderEnum,
+    Entities,
+    Entities
+  >;
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+
+  constructor(
+    protected readonly stripeClient: Stripe,
+    protected readonly 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,
+          plan: Stripe.Plan
+        ) => Promise<Entities['CreatePlanMapper']>
+      >;
+      UpdatePlanMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['UpdatePlanMapper'],
+        Entities['UpdatePlanMapper'],
+        (
+          dto: Dto['UpdatePlanMapper'],
+          em: EntityManager,
+          plan: Stripe.Plan
+        ) => Promise<Entities['UpdatePlanMapper']>
+      >;
+    },
+    readonly options?: {
+      telemetry?: TelemetryOptions;
+      databaseTableName?: string;
+    }
+  ) {
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
+    this.basePlanService = new BasePlanService(
+      em,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        PlanMapper: IdentityResponseMapper<Entities['PlanMapper']>,
+        CreatePlanMapper: IdentityRequestMapper<Entities['CreatePlanMapper']>,
+        UpdatePlanMapper: IdentityRequestMapper<Entities['UpdatePlanMapper']>
+      },
+      options
+    );
+  }
+
+  async createPlan(
+    planDto: Dto['CreatePlanMapper'],
+    em?: EntityManager
+  ): Promise<Dto['PlanMapper']> {
+    const plan = await this.stripeClient.plans.create({
+      ...planDto.stripeFields,
+      interval: planDto.cadence,
+      product: planDto.name,
+      currency: planDto.currency as string
+    });
+
+    const planEntity = await this.basePlanService.createPlan(
+      await this._mappers.CreatePlanMapper.deserializeDtoToEntity(
+        {
+          ...planDto,
+          externalId: plan.id,
+          billingProvider: 'stripe'
+        },
+        em ?? this.em,
+        plan
+      ),
+      em
+    );
+
+    return this._mappers.PlanMapper.serializeEntityToDto(planEntity);
+  }
+
+  async getPlan(idDto: IdDto, em?: EntityManager): Promise<Dto['PlanMapper']> {
+    const plan = await this.stripeClient.plans.retrieve(idDto.id);
+    const id = (
+      await em?.findOne<{ id: string; externalId: string }>(
+        this.options?.databaseTableName ?? 'plan',
+        { externalId: idDto.id }
+      )
+    )?.id;
+    if (!id) {
+      throw new Error('Plan not found');
+    }
+    return {
+      ...(await this._mappers.PlanMapper.serializeEntityToDto(
+        await this.basePlanService.getPlan({ id }, em)
+      )),
+      stripeFields: plan
+    };
+  }
+
+  async updatePlan(
+    planDto: Dto['UpdatePlanMapper'],
+    em?: EntityManager
+  ): Promise<Dto['PlanMapper']> {
+    const existingPlan = await this.stripeClient.plans.retrieve(planDto.id);
+    const plan = await this.stripeClient.plans.del(planDto.id).then(() =>
+      this.stripeClient.plans.create({
+        ...planDto.stripeFields,
+        interval: planDto.cadence ?? existingPlan.interval,
+        product: planDto.name,
+        currency: planDto.currency ?? existingPlan.currency
+      })
+    );
+
+    const planEntity = await this.basePlanService.updatePlan(
+      await this._mappers.UpdatePlanMapper.deserializeDtoToEntity(
+        {
+          ...planDto,
+          externalId: plan.id,
+          billingProvider: 'stripe'
+        },
+        em ?? this.em,
+        plan
+      ),
+      em
+    );
+
+    return this._mappers.PlanMapper.serializeEntityToDto(planEntity);
+  }
+
+  async deletePlan(idDto: { id: string }, em?: EntityManager): Promise<void> {
+    await this.stripeClient.plans.del(idDto.id);
+    await this.basePlanService.deletePlan(idDto, em);
+  }
+
+  async listPlans(
+    idsDto?: IdsDto,
+    em?: EntityManager
+  ): Promise<Dto['PlanMapper'][]> {
+    const plans = await this.stripeClient.plans.list({
+      active: true
+    });
+    const ids = (
+      await em?.findAll<{ id: string; externalId: string }>(
+        this.options?.databaseTableName ?? 'plan',
+        { where: { externalId: { $in: plans.data.map((plan) => plan.id) } } }
+      )
+    )
+      ?.filter((s) => idsDto?.ids?.includes(s.id))
+      ?.map((s) => s.id);
+
+    if (!ids) {
+      throw new Error('Plans not found');
+    }
+    return await Promise.all(
+      (await this.basePlanService.listPlans({ ids }, em)).map(async (plan) => ({
+        ...(await this._mappers.PlanMapper.serializeEntityToDto(plan)),
+        stripeFields: plans.data.find(
+          (stripePlan) => stripePlan.id === plan.externalId
+        )
+      }))
+    );
+  }
+}

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

@@ -0,0 +1,285 @@
+import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
+import { BaseSubscriptionService } from '@forklaunch/implementation-billing-base/services';
+import { SubscriptionService } 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 { BillingProviderEnum } from '../domain/enums/billingProvider.enum';
+import {
+  StripeCreateSubscriptionDto,
+  StripeSubscriptionDto,
+  StripeSubscriptionDtos,
+  StripeUpdateSubscriptionDto
+} from '../types/stripe.dto.types';
+import { StripeSubscriptionEntities } from '../types/stripe.entity.types';
+
+export class StripeSubscriptionService<
+  SchemaValidator extends AnySchemaValidator,
+  PartyType,
+  Entities extends StripeSubscriptionEntities<PartyType>,
+  Dto extends
+    StripeSubscriptionDtos<PartyType> = StripeSubscriptionDtos<PartyType>
+> implements
+    SubscriptionService<
+      PartyType,
+      typeof BillingProviderEnum,
+      {
+        CreateSubscriptionDto: StripeCreateSubscriptionDto<PartyType>;
+        UpdateSubscriptionDto: StripeUpdateSubscriptionDto<PartyType>;
+        SubscriptionDto: StripeSubscriptionDto<PartyType>;
+        IdDto: IdDto;
+        IdsDto: IdsDto;
+      }
+    >
+{
+  baseSubscriptionService: BaseSubscriptionService<
+    SchemaValidator,
+    PartyType,
+    typeof BillingProviderEnum,
+    Entities,
+    Entities
+  >;
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+
+  constructor(
+    protected readonly stripe: Stripe,
+    protected readonly em: EntityManager,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    protected readonly schemaValidator: SchemaValidator,
+    protected readonly mappers: {
+      SubscriptionMapper: ResponseMapperConstructor<
+        SchemaValidator,
+        Dto['SubscriptionMapper'],
+        Entities['SubscriptionMapper']
+      >;
+      CreateSubscriptionMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['CreateSubscriptionMapper'],
+        Entities['CreateSubscriptionMapper'],
+        (
+          dto: Dto['CreateSubscriptionMapper'],
+          em: EntityManager,
+          subscription: Stripe.Subscription
+        ) => Promise<Entities['CreateSubscriptionMapper']>
+      >;
+      UpdateSubscriptionMapper: RequestMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateSubscriptionMapper'],
+        Entities['UpdateSubscriptionMapper'],
+        (
+          dto: Dto['UpdateSubscriptionMapper'],
+          em: EntityManager,
+          subscription: Stripe.Subscription
+        ) => Promise<Entities['UpdateSubscriptionMapper']>
+      >;
+    },
+    readonly options?: {
+      telemetry?: TelemetryOptions;
+      databaseTableName?: string;
+    }
+  ) {
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
+    this.baseSubscriptionService = new BaseSubscriptionService(
+      em,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        SubscriptionMapper: IdentityResponseMapper<
+          Entities['SubscriptionMapper']
+        >,
+        CreateSubscriptionMapper: IdentityRequestMapper<
+          Entities['CreateSubscriptionMapper']
+        >,
+        UpdateSubscriptionMapper: IdentityRequestMapper<
+          Entities['UpdateSubscriptionMapper']
+        >
+      },
+      options
+    );
+  }
+
+  async createSubscription(
+    subscriptionDto: Dto['CreateSubscriptionMapper'],
+    em?: EntityManager
+  ): Promise<Dto['SubscriptionMapper']> {
+    const subscription = await this.stripe.subscriptions.create({
+      ...subscriptionDto.stripeFields,
+      customer: subscriptionDto.partyId,
+      items: [
+        {
+          plan: subscriptionDto.productId
+        }
+      ]
+    });
+
+    const subscriptionEntity =
+      await this.baseSubscriptionService.createSubscription(
+        await this._mappers.CreateSubscriptionMapper.deserializeDtoToEntity(
+          {
+            ...subscriptionDto,
+            externalId: subscription.id,
+            billingProvider: 'stripe'
+          },
+          em ?? this.em,
+          subscription
+        ),
+        em
+      );
+
+    return this._mappers.SubscriptionMapper.serializeEntityToDto(
+      subscriptionEntity
+    );
+  }
+
+  async getSubscription(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['SubscriptionMapper']> {
+    return {
+      ...(await this._mappers.SubscriptionMapper.serializeEntityToDto(
+        await this.baseSubscriptionService.getSubscription(idDto, em)
+      )),
+      stripeFields: await this.stripe.subscriptions.retrieve(idDto.id)
+    };
+  }
+
+  async getUserSubscription(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['SubscriptionMapper']> {
+    return {
+      ...(await this._mappers.SubscriptionMapper.serializeEntityToDto(
+        await this.baseSubscriptionService.getUserSubscription(idDto, em)
+      )),
+      stripeFields: await this.stripe.subscriptions.retrieve(idDto.id)
+    };
+  }
+
+  async getOrganizationSubscription(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['SubscriptionMapper']> {
+    const id = (
+      await em?.findOne<{ id: string; externalId: string }>(
+        this.options?.databaseTableName ?? 'subscription',
+        { externalId: idDto.id }
+      )
+    )?.id;
+    if (!id) {
+      throw new Error('Subscription not found');
+    }
+    return {
+      ...(await this._mappers.SubscriptionMapper.serializeEntityToDto(
+        await this.baseSubscriptionService.getOrganizationSubscription(
+          { id },
+          em
+        )
+      )),
+      stripeFields: await this.stripe.subscriptions.retrieve(idDto.id)
+    };
+  }
+
+  async updateSubscription(
+    subscriptionDto: Dto['UpdateSubscriptionMapper'],
+    em?: EntityManager
+  ): Promise<Dto['SubscriptionMapper']> {
+    const subscription = await this.stripe.subscriptions.update(
+      subscriptionDto.id,
+      {
+        ...subscriptionDto.stripeFields,
+        items: [
+          {
+            plan: subscriptionDto.productId
+          }
+        ]
+      }
+    );
+
+    const subscriptionEntity =
+      await this.baseSubscriptionService.updateSubscription(
+        await this._mappers.UpdateSubscriptionMapper.deserializeDtoToEntity(
+          {
+            ...subscriptionDto,
+            externalId: subscription.id,
+            billingProvider: 'stripe',
+            providerFields: subscription
+          },
+          em ?? this.em,
+          subscription
+        ),
+        em
+      );
+
+    return this._mappers.SubscriptionMapper.serializeEntityToDto(
+      subscriptionEntity
+    );
+  }
+
+  async deleteSubscription(
+    idDto: { id: string },
+    em?: EntityManager
+  ): Promise<void> {
+    await this.stripe.subscriptions.cancel(idDto.id);
+    await this.baseSubscriptionService.deleteSubscription(idDto, em);
+  }
+
+  async listSubscriptions(
+    idsDto: IdsDto,
+    em?: EntityManager
+  ): Promise<Dto['SubscriptionMapper'][]> {
+    const subscriptions = (
+      await this.stripe.subscriptions.list({
+        status: 'active'
+      })
+    ).data.filter((s) => idsDto.ids?.includes(s.id));
+
+    const ids = (
+      await em?.findAll<{ id: string; externalId: string }>(
+        this.options?.databaseTableName ?? 'subscription',
+        { where: { externalId: { $in: subscriptions.map((s) => s.id) } } }
+      )
+    )?.map((s) => s.id);
+
+    if (!ids) {
+      throw new Error('Subscriptions not found');
+    }
+
+    return await Promise.all(
+      (await this.baseSubscriptionService.listSubscriptions({ ids }, em)).map(
+        async (subscription) => {
+          return {
+            ...(await this._mappers.SubscriptionMapper.serializeEntityToDto(
+              subscription
+            )),
+            stripeFields: subscriptions.find(
+              (s) => s.id === subscription.externalId
+            )
+          };
+        }
+      )
+    );
+  }
+
+  async cancelSubscription(idDto: IdDto, em?: EntityManager): Promise<void> {
+    await this.stripe.subscriptions.cancel(idDto.id);
+    await this.baseSubscriptionService.cancelSubscription(idDto, em);
+  }
+
+  async resumeSubscription(idDto: IdDto, em?: EntityManager): Promise<void> {
+    await this.stripe.subscriptions.resume(idDto.id);
+    await this.baseSubscriptionService.resumeSubscription(idDto, em);
+  }
+}