@forklaunch/implementation-billing-stripe 0.0.1

package/lib/services/index.js

@@ -0,0 +1,788 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// services/index.ts
+var services_exports = {};
+__export(services_exports, {
+  StripeBillingPortalService: () => StripeBillingPortalService,
+  StripeCheckoutSessionService: () => StripeCheckoutSessionService,
+  StripePaymentLinkService: () => StripePaymentLinkService,
+  StripePlanService: () => StripePlanService,
+  StripeSubscriptionService: () => StripeSubscriptionService,
+  StripeWebhookService: () => StripeWebhookService
+});
+module.exports = __toCommonJS(services_exports);
+
+// services/billingPortal.service.ts
+var import_services = require("@forklaunch/implementation-billing-base/services");
+var import_internal = require("@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 = (0, import_internal.transformIntoInternalMapper)(mappers, schemaValidator);
+    this.baseBillingPortalService = new import_services.BaseBillingPortalService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        BillingPortalMapper: import_internal.IdentityResponseMapper,
+        CreateBillingPortalMapper: import_internal.IdentityRequestMapper,
+        UpdateBillingPortalMapper: import_internal.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
+var import_services2 = require("@forklaunch/implementation-billing-base/services");
+var import_internal2 = require("@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 = (0, import_internal2.transformIntoInternalMapper)(mappers, schemaValidator);
+    this.baseCheckoutSessionService = new import_services2.BaseCheckoutSessionService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        CheckoutSessionMapper: import_internal2.IdentityResponseMapper,
+        CreateCheckoutSessionMapper: import_internal2.IdentityRequestMapper,
+        UpdateCheckoutSessionMapper: import_internal2.IdentityRequestMapper
+      },
+      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
+var import_services3 = require("@forklaunch/implementation-billing-base/services");
+var import_internal3 = require("@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 = (0, import_internal3.transformIntoInternalMapper)(mappers, schemaValidator);
+    this.basePaymentLinkService = new import_services3.BasePaymentLinkService(
+      em,
+      cache,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        PaymentLinkMapper: import_internal3.IdentityResponseMapper,
+        CreatePaymentLinkMapper: import_internal3.IdentityRequestMapper,
+        UpdatePaymentLinkMapper: import_internal3.IdentityRequestMapper
+      },
+      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
+var import_services4 = require("@forklaunch/implementation-billing-base/services");
+var import_internal4 = require("@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 = (0, import_internal4.transformIntoInternalMapper)(mappers, schemaValidator);
+    this.basePlanService = new import_services4.BasePlanService(
+      em,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        PlanMapper: import_internal4.IdentityResponseMapper,
+        CreatePlanMapper: import_internal4.IdentityRequestMapper,
+        UpdatePlanMapper: import_internal4.IdentityRequestMapper
+      },
+      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
+var import_services5 = require("@forklaunch/implementation-billing-base/services");
+var import_internal5 = require("@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 = (0, import_internal5.transformIntoInternalMapper)(mappers, schemaValidator);
+    this.baseSubscriptionService = new import_services5.BaseSubscriptionService(
+      em,
+      openTelemetryCollector,
+      schemaValidator,
+      {
+        SubscriptionMapper: import_internal5.IdentityResponseMapper,
+        CreateSubscriptionMapper: import_internal5.IdentityRequestMapper,
+        UpdateSubscriptionMapper: import_internal5.IdentityRequestMapper
+      },
+      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;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StripeBillingPortalService,
+  StripeCheckoutSessionService,
+  StripePaymentLinkService,
+  StripePlanService,
+  StripeSubscriptionService,
+  StripeWebhookService
+});