@forklaunch/implementation-billing-base 0.3.2 → 0.3.4

package/lib/services/index.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -8,14 +8,18 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
+  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 });
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
   }
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, '__esModule', { value: true }), mod);
 
 // services/index.ts
 var services_exports = {};
@@ -29,46 +33,60 @@ __export(services_exports, {
 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 import_cache = require('@forklaunch/core/cache');
+var import_http = require('@forklaunch/core/http');
+var import_internal = require('@forklaunch/internal');
 var BaseBillingPortalService = class {
-  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+  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._mappers = (0, import_internal.transformIntoInternalMapper)(
+      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;
+    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");
+  createCacheKey = (0, import_cache.createCacheKey)('billing_portal_session');
   async createBillingPortalSession(billingPortalDto) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        "Creating billing portal session",
+        'Creating billing portal session',
         billingPortalDto
       );
     }
-    const billingPortal = await this.#mappers.CreateBillingPortalDtoMapper.deserializeDtoToEntity(
-      billingPortalDto,
-      this.em
-    );
+    const billingPortal =
+      await this._mappers.CreateBillingPortalMapper.deserializeDtoToEntity(
+        billingPortalDto,
+        this.em
+      );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(billingPortal);
     }
-    const createdBillingPortalDto = await this.#mappers.BillingPortalDtoMapper.serializeEntityToDto(
-      billingPortal
-    );
+    const createdBillingPortalDto =
+      await this._mappers.BillingPortalMapper.serializeEntityToDto(
+        billingPortal
+      );
     await this.cache.putRecord({
       key: this.createCacheKey(createdBillingPortalDto.id),
       value: createdBillingPortalDto,
@@ -78,31 +96,34 @@ var BaseBillingPortalService = class {
   }
   async getBillingPortalSession(idDto) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Getting billing portal session", idDto);
+      this.openTelemetryCollector.info('Getting billing portal session', idDto);
     }
-    const billingPortalDetails = await this.cache.readRecord(this.createCacheKey(idDto.id));
+    const billingPortalDetails = await this.cache.readRecord(
+      this.createCacheKey(idDto.id)
+    );
     if (!billingPortalDetails) {
-      throw new Error("Session not found");
+      throw new Error('Session not found');
     }
     return billingPortalDetails.value;
   }
   async updateBillingPortalSession(billingPortalDto) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        "Updating billing portal session",
+        'Updating billing portal session',
         billingPortalDto
       );
     }
-    const existingBillingPortal = (await this.cache.readRecord(
-      this.createCacheKey(billingPortalDto.id)
-    ))?.value;
+    const existingBillingPortal = (
+      await this.cache.readRecord(this.createCacheKey(billingPortalDto.id))
+    )?.value;
     if (!existingBillingPortal) {
-      throw new Error("Session not found");
+      throw new Error('Session not found');
     }
-    const billingPortal = await this.#mappers.UpdateBillingPortalDtoMapper.deserializeDtoToEntity(
-      billingPortalDto,
-      this.em
-    );
+    const billingPortal =
+      await this._mappers.UpdateBillingPortalMapper.deserializeDtoToEntity(
+        billingPortalDto,
+        this.em
+      );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush({
         billingPortal
@@ -110,9 +131,9 @@ var BaseBillingPortalService = class {
     }
     const updatedBillingPortalDto = {
       ...existingBillingPortal,
-      ...await this.#mappers.BillingPortalDtoMapper.serializeEntityToDto(
+      ...(await this._mappers.BillingPortalMapper.serializeEntityToDto(
         billingPortal
-      )
+      ))
     };
     await this.cache.putRecord({
       key: this.createCacheKey(updatedBillingPortalDto.id),
@@ -124,7 +145,7 @@ var BaseBillingPortalService = class {
   async expireBillingPortalSession(idDto) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        "Expiring billing portal session",
+        'Expiring billing portal session',
         idDto
       );
     }
@@ -132,50 +153,64 @@ var BaseBillingPortalService = class {
       this.createCacheKey(idDto.id)
     );
     if (!sessionExists) {
-      throw new Error("Session not found");
+      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 import_cache2 = require('@forklaunch/core/cache');
+var import_http2 = require('@forklaunch/core/http');
+var import_internal2 = require('@forklaunch/internal');
 var BaseCheckoutSessionService = class {
-  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+  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._mappers = (0, import_internal2.transformIntoInternalMapper)(
+      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;
+    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");
+  createCacheKey = (0, import_cache2.createCacheKey)('checkout_session');
   async createCheckoutSession(checkoutSessionDto) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        "Creating checkout session",
+        'Creating checkout session',
         checkoutSessionDto
       );
     }
-    const checkoutSession = await this.#mappers.CreateCheckoutSessionDtoMapper.deserializeDtoToEntity(
-      checkoutSessionDto,
-      this.em
-    );
-    const createdCheckoutSessionDto = await this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
-      checkoutSession
-    );
+    const checkoutSession =
+      await this._mappers.CreateCheckoutSessionMapper.deserializeDtoToEntity(
+        checkoutSessionDto,
+        this.em
+      );
+    const createdCheckoutSessionDto =
+      await this._mappers.CheckoutSessionMapper.serializeEntityToDto(
+        checkoutSession
+      );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(checkoutSession);
     }
@@ -186,14 +221,14 @@ var BaseCheckoutSessionService = class {
     });
     return createdCheckoutSessionDto;
   }
-  async getCheckoutSession({
-    id
-  }) {
-    const checkoutSessionDetails = await this.cache.readRecord(this.createCacheKey(id));
+  async getCheckoutSession({ id }) {
+    const checkoutSessionDetails = await this.cache.readRecord(
+      this.createCacheKey(id)
+    );
     if (!checkoutSessionDetails) {
-      throw new Error("Session not found");
+      throw new Error('Session not found');
     }
-    return this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+    return this._mappers.CheckoutSessionMapper.serializeEntityToDto(
       checkoutSessionDetails.value
     );
   }
@@ -202,18 +237,18 @@ var BaseCheckoutSessionService = class {
       this.createCacheKey(id)
     );
     if (!checkoutSessionDetails) {
-      throw new Error("Session not found");
+      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 });
+      this.openTelemetryCollector.info('Checkout success', { id });
     }
     if (this.enableDatabaseBackup) {
-      const checkoutSession = await this.em.upsert("CheckoutSession", {
+      const checkoutSession = await this.em.upsert('CheckoutSession', {
         id,
-        status: "SUCCESS"
+        status: 'SUCCESS'
       });
       await this.em.persistAndFlush(checkoutSession);
     }
@@ -221,12 +256,12 @@ var BaseCheckoutSessionService = class {
   }
   async handleCheckoutFailure({ id }) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Checkout failure", { id });
+      this.openTelemetryCollector.info('Checkout failure', { id });
     }
     if (this.enableDatabaseBackup) {
-      const checkoutSession = await this.em.upsert("CheckoutSession", {
+      const checkoutSession = await this.em.upsert('CheckoutSession', {
         id,
-        status: "FAILED"
+        status: 'FAILED'
       });
       await this.em.persistAndFlush(checkoutSession);
     }
@@ -235,44 +270,56 @@ var BaseCheckoutSessionService = class {
 };
 
 // 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 import_cache3 = require('@forklaunch/core/cache');
+var import_http3 = require('@forklaunch/core/http');
+var import_internal3 = require('@forklaunch/internal');
 var BasePaymentLinkService = class {
-  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+  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._mappers = (0, import_internal3.transformIntoInternalMapper)(
+      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;
+    this.evaluatedTelemetryOptions = options?.telemetry
+      ? (0, import_http3.evaluateTelemetryOptions)(options.telemetry).enabled
+      : {
+          logging: false,
+          metrics: false,
+          tracing: false
+        };
+  }
+  _mappers;
   evaluatedTelemetryOptions;
   enableDatabaseBackup;
-  cacheKeyPrefix = "payment_link";
+  cacheKeyPrefix = 'payment_link';
   createCacheKey = (0, import_cache3.createCacheKey)(this.cacheKeyPrefix);
   async createPaymentLink(paymentLinkDto) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Creating payment link", paymentLinkDto);
+      this.openTelemetryCollector.info('Creating payment link', paymentLinkDto);
     }
-    const paymentLink = await this.#mappers.CreatePaymentLinkDtoMapper.deserializeDtoToEntity(
-      paymentLinkDto,
-      this.em
-    );
+    const paymentLink =
+      await this._mappers.CreatePaymentLinkMapper.deserializeDtoToEntity(
+        paymentLinkDto,
+        this.em
+      );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(paymentLink);
     }
-    const createdPaymentLinkDto = await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
-      paymentLink
-    );
+    const createdPaymentLinkDto =
+      await this._mappers.PaymentLinkMapper.serializeEntityToDto(paymentLink);
     await this.cache.putRecord({
       key: this.createCacheKey(createdPaymentLinkDto.id),
       value: createdPaymentLinkDto,
@@ -282,25 +329,26 @@ var BasePaymentLinkService = class {
   }
   async updatePaymentLink(paymentLinkDto) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Updating payment link", paymentLinkDto);
+      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");
+      throw new Error('Payment link not found');
     }
-    const paymentLink = await this.#mappers.UpdatePaymentLinkDtoMapper.deserializeDtoToEntity(
-      paymentLinkDto,
-      this.em
-    );
+    const paymentLink =
+      await this._mappers.UpdatePaymentLinkMapper.deserializeDtoToEntity(
+        paymentLinkDto,
+        this.em
+      );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(paymentLink);
     }
     const updatedLinkDto = {
       ...existingLink,
-      ...await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+      ...(await this._mappers.PaymentLinkMapper.serializeEntityToDto(
         paymentLink
-      )
+      ))
     };
     await this.cache.putRecord({
       key: cacheKey,
@@ -311,58 +359,61 @@ var BasePaymentLinkService = class {
   }
   async getPaymentLink({ id }) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Getting payment link", { id });
+      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");
+      throw new Error('Payment link not found');
     }
-    return this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+    return this._mappers.PaymentLinkMapper.serializeEntityToDto(
       paymentLink.value
     );
   }
   async expirePaymentLink({ id }) {
-    this.openTelemetryCollector.info("Payment link expired", { id });
+    this.openTelemetryCollector.info('Payment link expired', { id });
     if (this.enableDatabaseBackup) {
-      const paymentLink = await this.em.upsert("PaymentLink", {
+      const paymentLink = await this.em.upsert('PaymentLink', {
         id,
-        status: "EXPIRED"
+        status: 'EXPIRED'
       });
       await this.em.removeAndFlush(paymentLink);
     }
     await this.cache.deleteRecord(this.createCacheKey(id));
   }
   async handlePaymentSuccess({ id }) {
-    this.openTelemetryCollector.info("Payment link success", { id });
+    this.openTelemetryCollector.info('Payment link success', { id });
     if (this.enableDatabaseBackup) {
-      const paymentLink = await this.em.upsert("PaymentLink", {
+      const paymentLink = await this.em.upsert('PaymentLink', {
         id,
-        status: "COMPLETED"
+        status: 'COMPLETED'
       });
       await this.em.removeAndFlush(paymentLink);
     }
     await this.cache.deleteRecord(this.createCacheKey(id));
   }
   async handlePaymentFailure({ id }) {
-    this.openTelemetryCollector.info("Payment link failure", { id });
+    this.openTelemetryCollector.info('Payment link failure', { id });
     if (this.enableDatabaseBackup) {
-      const paymentLink = await this.em.upsert("PaymentLink", {
+      const paymentLink = await this.em.upsert('PaymentLink', {
         id,
-        status: "FAILED"
+        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);
+    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
-        );
+        const paymentLinkDto =
+          this._mappers.PaymentLinkMapper.serializeEntityToDto(
+            paymentLink.value
+          );
         return paymentLinkDto;
       })
     );
@@ -370,8 +421,8 @@ var BasePaymentLinkService = class {
 };
 
 // services/plan.service.ts
-var import_http4 = require("@forklaunch/core/http");
-var import_mappers4 = require("@forklaunch/core/mappers");
+var import_http4 = require('@forklaunch/core/http');
+var import_internal4 = require('@forklaunch/internal');
 var BasePlanService = class {
   constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
     this.em = em;
@@ -379,56 +430,57 @@ var BasePlanService = class {
     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;
+    this._mappers = (0, import_internal4.transformIntoInternalMapper)(
+      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);
+      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
-        )
-      )
+      (
+        await (em ?? this.em).findAll('Plan', {
+          filters: idsDto?.ids ? { id: { $in: idsDto.ids } } : void 0
+        })
+      ).map((plan) => this._mappers.PlanMapper.serializeEntityToDto(plan))
     );
   }
   async createPlan(planDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Creating plan", planDto);
+      this.openTelemetryCollector.info('Creating plan', planDto);
     }
-    const plan = await this.#mappers.CreatePlanDtoMapper.deserializeDtoToEntity(
+    const plan = await this._mappers.CreatePlanMapper.deserializeDtoToEntity(
       planDto,
       em ?? this.em
     );
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(plan);
     });
-    return this.#mappers.PlanDtoMapper.serializeEntityToDto(plan);
+    return this._mappers.PlanMapper.serializeEntityToDto(plan);
   }
   async getPlan(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Getting plan", idDto);
+      this.openTelemetryCollector.info('Getting plan', idDto);
     }
-    const plan = await (em ?? this.em).findOneOrFail("Plan", idDto);
-    return this.#mappers.PlanDtoMapper.serializeEntityToDto(
-      plan
-    );
+    const plan = await (em ?? this.em).findOneOrFail('Plan', idDto);
+    return this._mappers.PlanMapper.serializeEntityToDto(plan);
   }
   async updatePlan(planDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Updating plan", planDto);
+      this.openTelemetryCollector.info('Updating plan', planDto);
     }
-    const plan = await this.#mappers.UpdatePlanDtoMapper.deserializeDtoToEntity(
+    const plan = await this._mappers.UpdatePlanMapper.deserializeDtoToEntity(
       planDto,
       em ?? this.em
     );
@@ -436,20 +488,21 @@ var BasePlanService = class {
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(plan);
     });
-    const updatedPlanDto = await this.#mappers.PlanDtoMapper.serializeEntityToDto(updatedPlan);
+    const updatedPlanDto =
+      await this._mappers.PlanMapper.serializeEntityToDto(updatedPlan);
     return updatedPlanDto;
   }
   async deletePlan(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Deleting plan", idDto);
+      this.openTelemetryCollector.info('Deleting plan', idDto);
     }
-    await (em ?? this.em).nativeDelete("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 import_http5 = require('@forklaunch/core/http');
+var import_internal5 = require('@forklaunch/internal');
 var BaseSubscriptionService = class {
   constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
     this.em = em;
@@ -457,129 +510,131 @@ var BaseSubscriptionService = class {
     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;
+    this._mappers = (0, import_internal5.transformIntoInternalMapper)(
+      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",
+        'Creating subscription',
         subscriptionDto
       );
     }
-    const subscription = await this.#mappers.CreateSubscriptionDtoMapper.deserializeDtoToEntity(
-      subscriptionDto,
-      em ?? this.em
-    );
+    const subscription =
+      await this._mappers.CreateSubscriptionMapper.deserializeDtoToEntity(
+        subscriptionDto,
+        em ?? this.em
+      );
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(subscription);
     });
-    const createdSubscriptionDto = await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-      subscription
-    );
+    const createdSubscriptionDto =
+      await this._mappers.SubscriptionMapper.serializeEntityToDto(subscription);
     return createdSubscriptionDto;
   }
   async getSubscription(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Getting subscription", idDto);
+      this.openTelemetryCollector.info('Getting subscription', idDto);
     }
     const subscription = await (em ?? this.em).findOneOrFail(
-      "Subscription",
+      'Subscription',
       idDto
     );
-    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-      subscription
-    );
+    return this._mappers.SubscriptionMapper.serializeEntityToDto(subscription);
   }
   async getUserSubscription({ id }, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Getting user subscription", id);
+      this.openTelemetryCollector.info('Getting user subscription', id);
     }
-    const subscription = await (em ?? this.em).findOneOrFail("Subscription", {
+    const subscription = await (em ?? this.em).findOneOrFail('Subscription', {
       partyId: id,
-      partyType: "USER",
+      partyType: 'USER',
       active: true
     });
-    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-      subscription
-    );
+    return this._mappers.SubscriptionMapper.serializeEntityToDto(subscription);
   }
   async getOrganizationSubscription({ id }, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Getting organization subscription", id);
+      this.openTelemetryCollector.info('Getting organization subscription', id);
     }
-    const subscription = await (em ?? this.em).findOneOrFail("Subscription", {
+    const subscription = await (em ?? this.em).findOneOrFail('Subscription', {
       partyId: id,
-      partyType: "ORGANIZATION",
+      partyType: 'ORGANIZATION',
       active: true
     });
-    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
-      subscription
-    );
+    return this._mappers.SubscriptionMapper.serializeEntityToDto(subscription);
   }
   async updateSubscription(subscriptionDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        "Updating subscription",
+        'Updating subscription',
         subscriptionDto
       );
     }
-    const subscription = this.#mappers.UpdateSubscriptionDtoMapper.deserializeDtoToEntity(
-      subscriptionDto,
-      em ?? this.em
-    );
+    const subscription =
+      this._mappers.UpdateSubscriptionMapper.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
-    );
+    const updatedSubscriptionDto =
+      await this._mappers.SubscriptionMapper.serializeEntityToDto(
+        updatedSubscription
+      );
     return updatedSubscriptionDto;
   }
   async deleteSubscription(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Deleting subscription", idDto);
+      this.openTelemetryCollector.info('Deleting subscription', idDto);
     }
-    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    const subscription = await (em ?? this.em).findOne('Subscription', idDto);
     if (!subscription) {
-      throw new Error("Subscription not found");
+      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
+      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
-        );
+        const subscriptionDto =
+          this._mappers.SubscriptionMapper.serializeEntityToDto(subscription);
         return subscriptionDto;
       })
     );
   }
   async cancelSubscription(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Canceling subscription", idDto);
+      this.openTelemetryCollector.info('Canceling subscription', idDto);
     }
-    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    const subscription = await (em ?? this.em).findOne('Subscription', idDto);
     if (!subscription) {
-      throw new Error("Subscription not found");
+      throw new Error('Subscription not found');
     }
     subscription.active = false;
     await (em ?? this.em).transactional(async (innerEm) => {
@@ -588,11 +643,11 @@ var BaseSubscriptionService = class {
   }
   async resumeSubscription(idDto, em) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info("Resuming subscription", idDto);
+      this.openTelemetryCollector.info('Resuming subscription', idDto);
     }
-    const subscription = await (em ?? this.em).findOne("Subscription", idDto);
+    const subscription = await (em ?? this.em).findOne('Subscription', idDto);
     if (!subscription) {
-      throw new Error("Subscription not found");
+      throw new Error('Subscription not found');
     }
     subscription.active = true;
     await (em ?? this.em).transactional(async (innerEm) => {
@@ -601,10 +656,11 @@ var BaseSubscriptionService = class {
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BaseBillingPortalService,
-  BaseCheckoutSessionService,
-  BasePaymentLinkService,
-  BasePlanService,
-  BaseSubscriptionService
-});
+0 &&
+  (module.exports = {
+    BaseBillingPortalService,
+    BaseCheckoutSessionService,
+    BasePaymentLinkService,
+    BasePlanService,
+    BaseSubscriptionService
+  });