@forklaunch/implementation-billing-base 0.2.2 → 0.3.0

package/lib/services/index.js

@@ -1,5 +1,610 @@
-export * from './billingPortal.service';
-export * from './checkoutSession.service';
-export * from './paymentLink.service';
-export * from './plan.service';
-export * from './subscription.service';
+"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, {
+  BaseBillingPortalService: () => BaseBillingPortalService,
+  BaseCheckoutSessionService: () => BaseCheckoutSessionService,
+  BasePaymentLinkService: () => BasePaymentLinkService,
+  BasePlanService: () => BasePlanService,
+  BaseSubscriptionService: () => BaseSubscriptionService
+});
+module.exports = __toCommonJS(services_exports);
+
+// services/billingPortal.service.ts
+var import_cache = require("@forklaunch/core/cache");
+var import_http = require("@forklaunch/core/http");
+var import_mappers = require("@forklaunch/core/mappers");
+var BaseBillingPortalService = class {
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = (0, import_mappers.transformIntoInternalDtoMapper)(mappers, schemaValidator);
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  enableDatabaseBackup;
+  createCacheKey = (0, import_cache.createCacheKey)("billing_portal_session");
+  async createBillingPortalSession(billingPortalDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating billing portal session",
+        billingPortalDto
+      );
+    }
+    const billingPortal = await this.#mappers.CreateBillingPortalDtoMapper.deserializeDtoToEntity(
+      billingPortalDto,
+      this.em
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(billingPortal);
+    }
+    const createdBillingPortalDto = await this.#mappers.BillingPortalDtoMapper.serializeEntityToDto(
+      billingPortal
+    );
+    await this.cache.putRecord({
+      key: this.createCacheKey(createdBillingPortalDto.id),
+      value: createdBillingPortalDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return createdBillingPortalDto;
+  }
+  async getBillingPortalSession(idDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting billing portal session", idDto);
+    }
+    const billingPortalDetails = await this.cache.readRecord(this.createCacheKey(idDto.id));
+    if (!billingPortalDetails) {
+      throw new Error("Session not found");
+    }
+    return billingPortalDetails.value;
+  }
+  async updateBillingPortalSession(billingPortalDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Updating billing portal session",
+        billingPortalDto
+      );
+    }
+    const existingBillingPortal = (await this.cache.readRecord(
+      this.createCacheKey(billingPortalDto.id)
+    ))?.value;
+    if (!existingBillingPortal) {
+      throw new Error("Session not found");
+    }
+    const billingPortal = await this.#mappers.UpdateBillingPortalDtoMapper.deserializeDtoToEntity(
+      billingPortalDto,
+      this.em
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush({
+        billingPortal
+      });
+    }
+    const updatedBillingPortalDto = {
+      ...existingBillingPortal,
+      ...await this.#mappers.BillingPortalDtoMapper.serializeEntityToDto(
+        billingPortal
+      )
+    };
+    await this.cache.putRecord({
+      key: this.createCacheKey(updatedBillingPortalDto.id),
+      value: updatedBillingPortalDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return updatedBillingPortalDto;
+  }
+  async expireBillingPortalSession(idDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Expiring billing portal session",
+        idDto
+      );
+    }
+    const sessionExists = await this.cache.readRecord(
+      this.createCacheKey(idDto.id)
+    );
+    if (!sessionExists) {
+      throw new Error("Session not found");
+    }
+    await this.cache.deleteRecord(this.createCacheKey(idDto.id));
+  }
+};
+
+// services/checkoutSession.service.ts
+var import_cache2 = require("@forklaunch/core/cache");
+var import_http2 = require("@forklaunch/core/http");
+var import_mappers2 = require("@forklaunch/core/mappers");
+var BaseCheckoutSessionService = class {
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = (0, import_mappers2.transformIntoInternalDtoMapper)(mappers, schemaValidator);
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http2.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  enableDatabaseBackup;
+  createCacheKey = (0, import_cache2.createCacheKey)("checkout_session");
+  async createCheckoutSession(checkoutSessionDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating checkout session",
+        checkoutSessionDto
+      );
+    }
+    const checkoutSession = await this.#mappers.CreateCheckoutSessionDtoMapper.deserializeDtoToEntity(
+      checkoutSessionDto,
+      this.em
+    );
+    const createdCheckoutSessionDto = await this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+      checkoutSession
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(checkoutSession);
+    }
+    await this.cache.putRecord({
+      key: this.createCacheKey(createdCheckoutSessionDto.id),
+      value: createdCheckoutSessionDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return createdCheckoutSessionDto;
+  }
+  async getCheckoutSession({
+    id
+  }) {
+    const checkoutSessionDetails = await this.cache.readRecord(this.createCacheKey(id));
+    if (!checkoutSessionDetails) {
+      throw new Error("Session not found");
+    }
+    return this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+      checkoutSessionDetails.value
+    );
+  }
+  async expireCheckoutSession({ id }) {
+    const checkoutSessionDetails = await this.cache.readRecord(
+      this.createCacheKey(id)
+    );
+    if (!checkoutSessionDetails) {
+      throw new Error("Session not found");
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async handleCheckoutSuccess({ id }) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Checkout success", { id });
+    }
+    if (this.enableDatabaseBackup) {
+      const checkoutSession = await this.em.upsert("CheckoutSession", {
+        id,
+        status: "SUCCESS"
+      });
+      await this.em.persistAndFlush(checkoutSession);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async handleCheckoutFailure({ id }) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Checkout failure", { id });
+    }
+    if (this.enableDatabaseBackup) {
+      const checkoutSession = await this.em.upsert("CheckoutSession", {
+        id,
+        status: "FAILED"
+      });
+      await this.em.persistAndFlush(checkoutSession);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+};
+
+// services/paymentLink.service.ts
+var import_cache3 = require("@forklaunch/core/cache");
+var import_http3 = require("@forklaunch/core/http");
+var import_mappers3 = require("@forklaunch/core/mappers");
+var BasePaymentLinkService = class {
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = (0, import_mappers3.transformIntoInternalDtoMapper)(mappers, schemaValidator);
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http3.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  enableDatabaseBackup;
+  cacheKeyPrefix = "payment_link";
+  createCacheKey = (0, import_cache3.createCacheKey)(this.cacheKeyPrefix);
+  async createPaymentLink(paymentLinkDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Creating payment link", paymentLinkDto);
+    }
+    const paymentLink = await this.#mappers.CreatePaymentLinkDtoMapper.deserializeDtoToEntity(
+      paymentLinkDto,
+      this.em
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(paymentLink);
+    }
+    const createdPaymentLinkDto = await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+      paymentLink
+    );
+    await this.cache.putRecord({
+      key: this.createCacheKey(createdPaymentLinkDto.id),
+      value: createdPaymentLinkDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return createdPaymentLinkDto;
+  }
+  async updatePaymentLink(paymentLinkDto) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating payment link", paymentLinkDto);
+    }
+    const cacheKey = this.createCacheKey(paymentLinkDto.id);
+    const existingLink = (await this.cache.readRecord(cacheKey))?.value;
+    if (!existingLink) {
+      throw new Error("Payment link not found");
+    }
+    const paymentLink = await this.#mappers.UpdatePaymentLinkDtoMapper.deserializeDtoToEntity(
+      paymentLinkDto,
+      this.em
+    );
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(paymentLink);
+    }
+    const updatedLinkDto = {
+      ...existingLink,
+      ...await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+        paymentLink
+      )
+    };
+    await this.cache.putRecord({
+      key: cacheKey,
+      value: updatedLinkDto,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+    return updatedLinkDto;
+  }
+  async getPaymentLink({ id }) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting payment link", { id });
+    }
+    const cacheKey = this.createCacheKey(id);
+    const paymentLink = await this.cache.readRecord(cacheKey);
+    if (!paymentLink) {
+      throw new Error("Payment link not found");
+    }
+    return this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+      paymentLink.value
+    );
+  }
+  async expirePaymentLink({ id }) {
+    this.openTelemetryCollector.info("Payment link expired", { id });
+    if (this.enableDatabaseBackup) {
+      const paymentLink = await this.em.upsert("PaymentLink", {
+        id,
+        status: "EXPIRED"
+      });
+      await this.em.removeAndFlush(paymentLink);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async handlePaymentSuccess({ id }) {
+    this.openTelemetryCollector.info("Payment link success", { id });
+    if (this.enableDatabaseBackup) {
+      const paymentLink = await this.em.upsert("PaymentLink", {
+        id,
+        status: "COMPLETED"
+      });
+      await this.em.removeAndFlush(paymentLink);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async handlePaymentFailure({ id }) {
+    this.openTelemetryCollector.info("Payment link failure", { id });
+    if (this.enableDatabaseBackup) {
+      const paymentLink = await this.em.upsert("PaymentLink", {
+        id,
+        status: "FAILED"
+      });
+      await this.em.removeAndFlush(paymentLink);
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+  async listPaymentLinks(idsDto) {
+    const keys = idsDto?.ids.map((id) => this.createCacheKey(id)) ?? await this.cache.listKeys(this.cacheKeyPrefix);
+    return Promise.all(
+      keys.map(async (key) => {
+        const paymentLink = await this.cache.readRecord(key);
+        const paymentLinkDto = this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+          paymentLink.value
+        );
+        return paymentLinkDto;
+      })
+    );
+  }
+};
+
+// services/plan.service.ts
+var import_http4 = require("@forklaunch/core/http");
+var import_mappers4 = require("@forklaunch/core/mappers");
+var BasePlanService = class {
+  constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = (0, import_mappers4.transformIntoInternalDtoMapper)(mappers, schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http4.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  async listPlans(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Listing plans", idsDto);
+    }
+    return Promise.all(
+      (await (em ?? this.em).findAll("Plan", {
+        filters: idsDto?.ids ? { id: { $in: idsDto.ids } } : void 0
+      })).map(
+        (plan) => this.#mappers.PlanDtoMapper.serializeEntityToDto(
+          plan
+        )
+      )
+    );
+  }
+  async createPlan(planDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Creating plan", planDto);
+    }
+    const plan = await this.#mappers.CreatePlanDtoMapper.deserializeDtoToEntity(
+      planDto,
+      em ?? this.em
+    );
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(plan);
+    });
+    return this.#mappers.PlanDtoMapper.serializeEntityToDto(plan);
+  }
+  async getPlan(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting plan", idDto);
+    }
+    const plan = await (em ?? this.em).findOneOrFail("Plan", idDto);
+    return this.#mappers.PlanDtoMapper.serializeEntityToDto(
+      plan
+    );
+  }
+  async updatePlan(planDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Updating plan", planDto);
+    }
+    const plan = await this.#mappers.UpdatePlanDtoMapper.deserializeDtoToEntity(
+      planDto,
+      em ?? this.em
+    );
+    const updatedPlan = await (em ?? this.em).upsert(plan);
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(plan);
+    });
+    const updatedPlanDto = await this.#mappers.PlanDtoMapper.serializeEntityToDto(updatedPlan);
+    return updatedPlanDto;
+  }
+  async deletePlan(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting plan", idDto);
+    }
+    await (em ?? this.em).nativeDelete("Plan", idDto);
+  }
+};
+
+// services/subscription.service.ts
+var import_http5 = require("@forklaunch/core/http");
+var import_mappers5 = require("@forklaunch/core/mappers");
+var BaseSubscriptionService = class {
+  constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.options = options;
+    this.#mappers = (0, import_mappers5.transformIntoInternalDtoMapper)(mappers, this.schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry ? (0, import_http5.evaluateTelemetryOptions)(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  #mappers;
+  evaluatedTelemetryOptions;
+  async createSubscription(subscriptionDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Creating subscription",
+        subscriptionDto
+      );
+    }
+    const subscription = await this.#mappers.CreateSubscriptionDtoMapper.deserializeDtoToEntity(
+      subscriptionDto,
+      em ?? this.em
+    );
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(subscription);
+    });
+    const createdSubscriptionDto = await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      subscription
+    );
+    return createdSubscriptionDto;
+  }
+  async getSubscription(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting subscription", idDto);
+    }
+    const subscription = await (em ?? this.em).findOneOrFail(
+      "Subscription",
+      idDto
+    );
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      subscription
+    );
+  }
+  async getUserSubscription({ id }, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting user subscription", id);
+    }
+    const subscription = await (em ?? this.em).findOneOrFail("Subscription", {
+      partyId: id,
+      partyType: "USER",
+      active: true
+    });
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      subscription
+    );
+  }
+  async getOrganizationSubscription({ id }, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Getting organization subscription", id);
+    }
+    const subscription = await (em ?? this.em).findOneOrFail("Subscription", {
+      partyId: id,
+      partyType: "ORGANIZATION",
+      active: true
+    });
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      subscription
+    );
+  }
+  async updateSubscription(subscriptionDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        "Updating subscription",
+        subscriptionDto
+      );
+    }
+    const subscription = this.#mappers.UpdateSubscriptionDtoMapper.deserializeDtoToEntity(
+      subscriptionDto,
+      em ?? this.em
+    );
+    const updatedSubscription = await (em ?? this.em).upsert(subscription);
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(updatedSubscription);
+    });
+    const updatedSubscriptionDto = await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+      updatedSubscription
+    );
+    return updatedSubscriptionDto;
+  }
+  async deleteSubscription(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Deleting subscription", idDto);
+    }
+    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    if (!subscription) {
+      throw new Error("Subscription not found");
+    }
+    await (em ?? this.em).removeAndFlush(subscription);
+  }
+  async listSubscriptions(idsDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Listing subscriptions", idsDto);
+    }
+    const subscriptions = await (em ?? this.em).findAll("Subscription", {
+      where: idsDto.ids ? {
+        id: {
+          $in: idsDto.ids
+        }
+      } : void 0
+    });
+    return Promise.all(
+      subscriptions.map((subscription) => {
+        const subscriptionDto = this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+          subscription
+        );
+        return subscriptionDto;
+      })
+    );
+  }
+  async cancelSubscription(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Canceling subscription", idDto);
+    }
+    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    if (!subscription) {
+      throw new Error("Subscription not found");
+    }
+    subscription.active = false;
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(subscription);
+    });
+  }
+  async resumeSubscription(idDto, em) {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info("Resuming subscription", idDto);
+    }
+    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    if (!subscription) {
+      throw new Error("Subscription not found");
+    }
+    subscription.active = true;
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(subscription);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseBillingPortalService,
+  BaseCheckoutSessionService,
+  BasePaymentLinkService,
+  BasePlanService,
+  BaseSubscriptionService
+});