@forklaunch/implementation-billing-stripe 0.0.1

package/lib/services/index.mjs

@@ -0,0 +1,776 @@
+// services/billingPortal.service.ts
+import { BaseBillingPortalService } from "@forklaunch/implementation-billing-base/services";
+import {
+  IdentityRequestMapper,
+  IdentityResponseMapper,
+  transformIntoInternalMapper
+} from "@forklaunch/internal";
+var StripeBillingPortalService = class {
+  constructor(stripeClient, em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.stripeClient = stripeClient;
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
+    this.baseBillingPortalService = new BaseBillingPortalService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        BillingPortalMapper: IdentityResponseMapper,
+        CreateBillingPortalMapper: IdentityRequestMapper,
+        UpdateBillingPortalMapper: IdentityRequestMapper
+      },
+      options
+    );
+  }
+  billingPortalSessionExpiryDurationMs = 5 * 60 * 1e3;
+  baseBillingPortalService;
+  _mappers;
+  async createBillingPortalSession(billingPortalDto) {
+    const session = await this.stripeClient.billingPortal.sessions.create({
+      ...billingPortalDto.stripeFields,
+      customer: billingPortalDto.customerId
+    });
+    const billingPortalEntity = await this.baseBillingPortalService.createBillingPortalSession(
+      await this._mappers.CreateBillingPortalMapper.deserializeDtoToEntity(
+        {
+          ...billingPortalDto,
+          id: session.id,
+          uri: session.url,
+          expiresAt: new Date(
+            Date.now() + this.billingPortalSessionExpiryDurationMs
+          )
+        },
+        this.em,
+        session
+      )
+    );
+    return this._mappers.BillingPortalMapper.serializeEntityToDto(
+      billingPortalEntity
+    );
+  }
+  async getBillingPortalSession(idDto) {
+    const billingPortalEntity = await this.baseBillingPortalService.getBillingPortalSession(idDto);
+    return this._mappers.BillingPortalMapper.serializeEntityToDto(
+      billingPortalEntity
+    );
+  }
+  async expireBillingPortalSession(idDto) {
+    return this.baseBillingPortalService.expireBillingPortalSession(idDto);
+  }
+  async updateBillingPortalSession(billingPortalDto) {
+    const existingSession = await this.baseBillingPortalService.getBillingPortalSession({
+      id: billingPortalDto.id
+    });
+    const session = await this.stripeClient.billingPortal.sessions.create({
+      ...billingPortalDto.stripeFields,
+      customer: existingSession.customerId
+    });
+    const baseBillingPortalDto = await this.baseBillingPortalService.updateBillingPortalSession(
+      await this._mappers.UpdateBillingPortalMapper.deserializeDtoToEntity(
+        {
+          ...billingPortalDto,
+          id: session.id,
+          uri: session.url,
+          expiresAt: new Date(
+            Date.now() + this.billingPortalSessionExpiryDurationMs
+          )
+        },
+        this.em,
+        session
+      )
+    );
+    return this._mappers.BillingPortalMapper.serializeEntityToDto(
+      baseBillingPortalDto
+    );
+  }
+};
+
+// services/checkoutSession.service.ts
+import { BaseCheckoutSessionService } from "@forklaunch/implementation-billing-base/services";
+import {
+  IdentityRequestMapper as IdentityRequestMapper2,
+  IdentityResponseMapper as IdentityResponseMapper2,
+  transformIntoInternalMapper as transformIntoInternalMapper2
+} from "@forklaunch/internal";
+var StripeCheckoutSessionService = class {
+  constructor(stripeClient, em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.stripeClient = stripeClient;
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this._mappers = transformIntoInternalMapper2(mappers, schemaValidator);
+    this.baseCheckoutSessionService = new BaseCheckoutSessionService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        CheckoutSessionMapper: IdentityResponseMapper2,
+        CreateCheckoutSessionMapper: IdentityRequestMapper2,
+        UpdateCheckoutSessionMapper: IdentityRequestMapper2
+      },
+      options
+    );
+  }
+  baseCheckoutSessionService;
+  _mappers;
+  async createCheckoutSession(checkoutSessionDto) {
+    const session = await this.stripeClient.checkout.sessions.create({
+      ...checkoutSessionDto.stripeFields,
+      payment_method_types: checkoutSessionDto.paymentMethods,
+      currency: checkoutSessionDto.currency,
+      success_url: checkoutSessionDto.successRedirectUri,
+      cancel_url: checkoutSessionDto.cancelRedirectUri
+    });
+    const checkoutSessionEntity = await this.baseCheckoutSessionService.createCheckoutSession(
+      await this._mappers.CreateCheckoutSessionMapper.deserializeDtoToEntity(
+        {
+          ...checkoutSessionDto,
+          id: session.id,
+          uri: session.url,
+          expiresAt: new Date(Date.now() + 5 * 60 * 1e3),
+          providerFields: session
+        },
+        this.em,
+        session
+      )
+    );
+    return this._mappers.CheckoutSessionMapper.serializeEntityToDto(
+      checkoutSessionEntity
+    );
+  }
+  async getCheckoutSession({
+    id
+  }) {
+    const databaseCheckoutSession = await this.baseCheckoutSessionService.getCheckoutSession({ id });
+    return {
+      ...this._mappers.CheckoutSessionMapper.serializeEntityToDto(
+        databaseCheckoutSession
+      ),
+      stripeFields: await this.stripeClient.checkout.sessions.retrieve(id)
+    };
+  }
+  async expireCheckoutSession({ id }) {
+    await this.stripeClient.checkout.sessions.expire(id);
+    await this.baseCheckoutSessionService.expireCheckoutSession({ id });
+  }
+  async handleCheckoutSuccess({ id }) {
+    await this.stripeClient.checkout.sessions.update(id, {
+      metadata: {
+        status: "SUCCESS"
+      }
+    });
+    await this.baseCheckoutSessionService.handleCheckoutSuccess({ id });
+  }
+  async handleCheckoutFailure({ id }) {
+    await this.stripeClient.checkout.sessions.update(id, {
+      metadata: {
+        status: "FAILED"
+      }
+    });
+    await this.baseCheckoutSessionService.handleCheckoutFailure({ id });
+  }
+};
+
+// services/paymentLink.service.ts
+import { BasePaymentLinkService } from "@forklaunch/implementation-billing-base/services";
+import {
+  IdentityRequestMapper as IdentityRequestMapper3,
+  IdentityResponseMapper as IdentityResponseMapper3,
+  transformIntoInternalMapper as transformIntoInternalMapper3
+} from "@forklaunch/internal";
+var StripePaymentLinkService = class {
+  constructor(stripeClient, em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.stripeClient = stripeClient;
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this._mappers = transformIntoInternalMapper3(mappers, schemaValidator);
+    this.basePaymentLinkService = new BasePaymentLinkService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        PaymentLinkMapper: IdentityResponseMapper3,
+        CreatePaymentLinkMapper: IdentityRequestMapper3,
+        UpdatePaymentLinkMapper: IdentityRequestMapper3
+      },
+      options
+    );
+  }
+  basePaymentLinkService;
+  _mappers;
+  async createPaymentLink(paymentLinkDto) {
+    const session = await this.stripeClient.paymentLinks.create({
+      ...paymentLinkDto.stripeFields,
+      payment_method_types: paymentLinkDto.paymentMethods,
+      currency: paymentLinkDto.currency
+    });
+    const paymentLinkEntity = await this.basePaymentLinkService.createPaymentLink(
+      await this._mappers.CreatePaymentLinkMapper.deserializeDtoToEntity(
+        {
+          ...paymentLinkDto,
+          id: session.id,
+          amount: session.line_items?.data.reduce(
+            (total, item) => total + item.amount_total,
+            0
+          ) ?? 0
+        },
+        this.em,
+        session
+      )
+    );
+    return this._mappers.PaymentLinkMapper.serializeEntityToDto(
+      paymentLinkEntity
+    );
+  }
+  async updatePaymentLink(paymentLinkDto) {
+    const session = await this.stripeClient.paymentLinks.update(
+      paymentLinkDto.id,
+      {
+        ...paymentLinkDto.stripeFields,
+        payment_method_types: paymentLinkDto.paymentMethods
+      }
+    );
+    const paymentLinkEntity = await this.basePaymentLinkService.updatePaymentLink(
+      await this._mappers.UpdatePaymentLinkMapper.deserializeDtoToEntity(
+        {
+          ...paymentLinkDto,
+          id: session.id,
+          amount: session.line_items?.data.reduce(
+            (total, item) => total + item.amount_total,
+            0
+          ) ?? 0
+        },
+        this.em,
+        session
+      )
+    );
+    return this._mappers.PaymentLinkMapper.serializeEntityToDto(
+      paymentLinkEntity
+    );
+  }
+  async getPaymentLink({ id }) {
+    const databasePaymentLink = await this.basePaymentLinkService.getPaymentLink({ id });
+    return {
+      ...this._mappers.PaymentLinkMapper.serializeEntityToDto(
+        databasePaymentLink
+      ),
+      stripeFields: await this.stripeClient.paymentLinks.retrieve(id)
+    };
+  }
+  async expirePaymentLink({ id }) {
+    await this.stripeClient.paymentLinks.update(id, {
+      metadata: {
+        status: "EXPIRED"
+      }
+    });
+    await this.basePaymentLinkService.expirePaymentLink({ id });
+  }
+  async handlePaymentSuccess({ id }) {
+    await this.stripeClient.paymentLinks.update(id, {
+      metadata: {
+        status: "COMPLETED"
+      }
+    });
+    await this.basePaymentLinkService.handlePaymentSuccess({ id });
+  }
+  async handlePaymentFailure({ id }) {
+    await this.stripeClient.paymentLinks.update(id, {
+      metadata: {
+        status: "FAILED"
+      }
+    });
+    await this.basePaymentLinkService.handlePaymentFailure({ id });
+  }
+  async listPaymentLinks(idsDto) {
+    const paymentLinks = await this.stripeClient.paymentLinks.list({
+      active: true
+    });
+    return await Promise.all(
+      (await this.basePaymentLinkService.listPaymentLinks(idsDto)).map(
+        async (paymentLink) => ({
+          ...await this._mappers.PaymentLinkMapper.serializeEntityToDto(
+            paymentLink
+          ),
+          stripeFields: paymentLinks.data.find(
+            (paymentLink2) => paymentLink2.id === paymentLink2.id
+          )
+        })
+      )
+    );
+  }
+};
+
+// services/plan.service.ts
+import { BasePlanService } from "@forklaunch/implementation-billing-base/services";
+import {
+  IdentityRequestMapper as IdentityRequestMapper4,
+  IdentityResponseMapper as IdentityResponseMapper4,
+  transformIntoInternalMapper as transformIntoInternalMapper4
+} from "@forklaunch/internal";
+var StripePlanService = class {
+  constructor(stripeClient, em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.stripeClient = stripeClient;
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this._mappers = transformIntoInternalMapper4(mappers, schemaValidator);
+    this.basePlanService = new BasePlanService(
+      em,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        PlanMapper: IdentityResponseMapper4,
+        CreatePlanMapper: IdentityRequestMapper4,
+        UpdatePlanMapper: IdentityRequestMapper4
+      },
+      options
+    );
+  }
+  basePlanService;
+  _mappers;
+  async createPlan(planDto, em) {
+    const plan = await this.stripeClient.plans.create({
+      ...planDto.stripeFields,
+      interval: planDto.cadence,
+      product: planDto.name,
+      currency: planDto.currency
+    });
+    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, em) {
+    const plan = await this.stripeClient.plans.retrieve(idDto.id);
+    const id = (await em?.findOne(
+      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, em) {
+    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, em) {
+    await this.stripeClient.plans.del(idDto.id);
+    await this.basePlanService.deletePlan(idDto, em);
+  }
+  async listPlans(idsDto, em) {
+    const plans = await this.stripeClient.plans.list({
+      active: true
+    });
+    const ids = (await em?.findAll(
+      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
+        )
+      }))
+    );
+  }
+};
+
+// services/subscription.service.ts
+import { BaseSubscriptionService } from "@forklaunch/implementation-billing-base/services";
+import {
+  IdentityRequestMapper as IdentityRequestMapper5,
+  IdentityResponseMapper as IdentityResponseMapper5,
+  transformIntoInternalMapper as transformIntoInternalMapper5
+} from "@forklaunch/internal";
+var StripeSubscriptionService = class {
+  constructor(stripe, em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.stripe = stripe;
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this._mappers = transformIntoInternalMapper5(mappers, schemaValidator);
+    this.baseSubscriptionService = new BaseSubscriptionService(
+      em,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        SubscriptionMapper: IdentityResponseMapper5,
+        CreateSubscriptionMapper: IdentityRequestMapper5,
+        UpdateSubscriptionMapper: IdentityRequestMapper5
+      },
+      options
+    );
+  }
+  baseSubscriptionService;
+  _mappers;
+  async createSubscription(subscriptionDto, em) {
+    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, em) {
+    return {
+      ...await this._mappers.SubscriptionMapper.serializeEntityToDto(
+        await this.baseSubscriptionService.getSubscription(idDto, em)
+      ),
+      stripeFields: await this.stripe.subscriptions.retrieve(idDto.id)
+    };
+  }
+  async getUserSubscription(idDto, em) {
+    return {
+      ...await this._mappers.SubscriptionMapper.serializeEntityToDto(
+        await this.baseSubscriptionService.getUserSubscription(idDto, em)
+      ),
+      stripeFields: await this.stripe.subscriptions.retrieve(idDto.id)
+    };
+  }
+  async getOrganizationSubscription(idDto, em) {
+    const id = (await em?.findOne(
+      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, em) {
+    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, em) {
+    await this.stripe.subscriptions.cancel(idDto.id);
+    await this.baseSubscriptionService.deleteSubscription(idDto, em);
+  }
+  async listSubscriptions(idsDto, em) {
+    const subscriptions = (await this.stripe.subscriptions.list({
+      status: "active"
+    })).data.filter((s) => idsDto.ids?.includes(s.id));
+    const ids = (await em?.findAll(
+      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, em) {
+    await this.stripe.subscriptions.cancel(idDto.id);
+    await this.baseSubscriptionService.cancelSubscription(idDto, em);
+  }
+  async resumeSubscription(idDto, em) {
+    await this.stripe.subscriptions.resume(idDto.id);
+    await this.baseSubscriptionService.resumeSubscription(idDto, em);
+  }
+};
+
+// services/webhook.service.ts
+var StripeWebhookService = class {
+  constructor(stripeClient, em, schemaValidator, openTelemetryCollector, billingPortalService, checkoutSessionService, paymentLinkService, planService, subscriptionService) {
+    this.stripeClient = stripeClient;
+    this.em = em;
+    this.schemaValidator = schemaValidator;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.billingPortalService = billingPortalService;
+    this.checkoutSessionService = checkoutSessionService;
+    this.paymentLinkService = paymentLinkService;
+    this.planService = planService;
+    this.subscriptionService = subscriptionService;
+  }
+  async handleWebhookEvent(event) {
+    if (this.openTelemetryCollector) {
+      this.openTelemetryCollector.info("Handling webhook event", event);
+    }
+    const eventType = event.type;
+    switch (eventType) {
+      case "billing_portal.session.created": {
+        this.billingPortalService.baseBillingPortalService.createBillingPortalSession(
+          {
+            id: event.data.object.id,
+            customerId: event.data.object.customer,
+            expiresAt: new Date(event.data.object.created + 5 * 60 * 1e3),
+            uri: event.data.object.url,
+            providerFields: event.data.object
+          }
+        );
+        break;
+      }
+      case "checkout.session.expired": {
+        this.checkoutSessionService.handleCheckoutFailure({
+          id: event.data.object.id
+        });
+        break;
+      }
+      case "checkout.session.completed": {
+        this.checkoutSessionService.handleCheckoutSuccess({
+          id: event.data.object.id
+        });
+        break;
+      }
+      case "payment_link.created":
+        {
+          this.paymentLinkService.basePaymentLinkService.createPaymentLink({
+            id: event.data.object.id,
+            amount: event.data.object.line_items?.data.reduce(
+              (total, item) => total + item.amount_total,
+              0
+            ) ?? 0,
+            paymentMethods: event.data.object.payment_method_types,
+            status: "CREATED",
+            currency: event.data.object.currency,
+            providerFields: event.data.object
+          });
+        }
+        break;
+      case "payment_link.updated": {
+        this.paymentLinkService.basePaymentLinkService.updatePaymentLink({
+          id: event.data.object.id,
+          amount: event.data.object.line_items?.data.reduce(
+            (total, item) => total + item.amount_total,
+            0
+          ) ?? 0,
+          paymentMethods: event.data.object.payment_method_types,
+          status: "UPDATED",
+          currency: event.data.object.currency,
+          providerFields: event.data.object
+        });
+        break;
+      }
+      case "plan.created": {
+        if (typeof event.data.object.product === "object" && event.data.object.product != null && event.data.object.amount != null) {
+          this.planService.basePlanService.createPlan({
+            id: event.data.object.id,
+            billingProvider: "stripe" /* STRIPE */,
+            cadence: event.data.object.interval,
+            currency: event.data.object.currency,
+            active: true,
+            name: typeof event.data.object.product === "string" ? event.data.object.product : event.data.object.product?.id,
+            price: event.data.object.amount,
+            externalId: event.data.object.id,
+            providerFields: event.data.object
+          });
+        } else {
+          throw new Error("Invalid plan");
+        }
+        break;
+      }
+      case "plan.updated": {
+        if (typeof event.data.object.product === "object" && event.data.object.product != null && event.data.object.amount != null) {
+          this.planService.basePlanService.updatePlan({
+            id: event.data.object.id,
+            billingProvider: "stripe" /* STRIPE */,
+            cadence: event.data.object.interval,
+            currency: event.data.object.currency,
+            active: true,
+            name: typeof event.data.object.product === "string" ? event.data.object.product : event.data.object.product?.id,
+            price: event.data.object.amount,
+            externalId: event.data.object.id,
+            providerFields: event.data.object
+          });
+        } else {
+          throw new Error("Invalid plan");
+        }
+        break;
+      }
+      case "plan.deleted": {
+        this.planService.deletePlan({
+          id: event.data.object.id
+        });
+        break;
+      }
+      case "customer.subscription.created": {
+        this.subscriptionService.baseSubscriptionService.createSubscription({
+          id: event.data.object.id,
+          partyId: typeof event.data.object.customer === "string" ? event.data.object.customer : event.data.object.customer.id,
+          partyType: "USER",
+          description: event.data.object.description ?? void 0,
+          active: true,
+          productId: event.data.object.items.data[0].plan.id,
+          providerFields: event.data.object,
+          externalId: event.data.object.id,
+          billingProvider: "stripe" /* STRIPE */,
+          startDate: new Date(event.data.object.created),
+          endDate: event.data.object.cancel_at ? new Date(event.data.object.cancel_at) : /* @__PURE__ */ new Date(Infinity),
+          status: event.data.object.status
+        });
+        break;
+      }
+      case "customer.subscription.updated": {
+        this.subscriptionService.baseSubscriptionService.updateSubscription({
+          id: event.data.object.id,
+          partyId: typeof event.data.object.customer === "string" ? event.data.object.customer : event.data.object.customer.id,
+          partyType: "USER",
+          description: event.data.object.description ?? void 0,
+          active: true,
+          providerFields: event.data.object,
+          externalId: event.data.object.id,
+          billingProvider: "stripe" /* STRIPE */,
+          startDate: new Date(event.data.object.created),
+          endDate: event.data.object.cancel_at ? new Date(event.data.object.cancel_at) : /* @__PURE__ */ new Date(Infinity),
+          productId: event.data.object.items.data[0].plan.id,
+          status: event.data.object.status
+        });
+        break;
+      }
+      case "customer.subscription.deleted": {
+        this.subscriptionService.deleteSubscription({
+          id: event.data.object.id
+        });
+        break;
+      }
+      case "customer.subscription.paused": {
+        this.subscriptionService.cancelSubscription({
+          id: event.data.object.id
+        });
+        break;
+      }
+      case "customer.subscription.resumed": {
+        this.subscriptionService.resumeSubscription({
+          id: event.data.object.id
+        });
+        break;
+      }
+      default:
+        this.openTelemetryCollector.info(
+          "Unprocessed stripe event type",
+          eventType
+        );
+        break;
+    }
+  }
+};
+export {
+  StripeBillingPortalService,
+  StripeCheckoutSessionService,
+  StripePaymentLinkService,
+  StripePlanService,
+  StripeSubscriptionService,
+  StripeWebhookService
+};