@forklaunch/implementation-billing-base 0.5.8 → 0.6.1

package/lib/services/index.mjs

@@ -1,33 +1,9 @@
 // services/billingPortal.service.ts
-import { createCacheKey } from '@forklaunch/core/cache';
-import { evaluateTelemetryOptions } from '@forklaunch/core/http';
-import { transformIntoInternalMapper } from '@forklaunch/internal';
+import { createCacheKey } from "@forklaunch/core/cache";
+import {
+  evaluateTelemetryOptions
+} from "@forklaunch/core/http";
 var BaseBillingPortalService = class {
-  constructor(
-    em,
-    cache,
-    openTelemetryCollector,
-    schemaValidator,
-    mappers,
-    options
-  ) {
-    this.options = options;
-    this.em = em;
-    this.cache = cache;
-    this.openTelemetryCollector = openTelemetryCollector;
-    this.schemaValidator = schemaValidator;
-    this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
-    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? evaluateTelemetryOptions(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
-  }
-  _mappers;
   evaluatedTelemetryOptions;
   enableDatabaseBackup;
   em;
@@ -35,26 +11,36 @@ var BaseBillingPortalService = class {
   openTelemetryCollector;
   schemaValidator;
   mappers;
-  createCacheKey = createCacheKey('billing_portal_session');
-  async createBillingPortalSession(billingPortalDto) {
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  createCacheKey = createCacheKey("billing_portal_session");
+  async createBillingPortalSession(billingPortalDto, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Creating billing portal session',
+        "Creating billing portal session",
         billingPortalDto
       );
     }
-    const billingPortal =
-      await this._mappers.CreateBillingPortalMapper.deserializeDtoToEntity(
-        billingPortalDto,
-        this.em
-      );
+    const billingPortal = await this.mappers.CreateBillingPortalMapper.toEntity(
+      billingPortalDto,
+      this.em,
+      ...args
+    );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(billingPortal);
     }
-    const createdBillingPortalDto =
-      await this._mappers.BillingPortalMapper.serializeEntityToDto(
-        billingPortal
-      );
+    const createdBillingPortalDto = await this.mappers.BillingPortalMapper.toDto(billingPortal);
     await this.cache.putRecord({
       key: this.createCacheKey(createdBillingPortalDto.id),
       value: createdBillingPortalDto,
@@ -64,34 +50,32 @@ 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) {
+  async updateBillingPortalSession(billingPortalDto, ...args) {
     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.UpdateBillingPortalMapper.deserializeDtoToEntity(
-        billingPortalDto,
-        this.em
-      );
+    const billingPortal = await this.mappers.UpdateBillingPortalMapper.toEntity(
+      billingPortalDto,
+      this.em,
+      ...args
+    );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush({
         billingPortal
@@ -99,9 +83,7 @@ var BaseBillingPortalService = class {
     }
     const updatedBillingPortalDto = {
       ...existingBillingPortal,
-      ...(await this._mappers.BillingPortalMapper.serializeEntityToDto(
-        billingPortal
-      ))
+      ...await this.mappers.BillingPortalMapper.toDto(billingPortal)
     };
     await this.cache.putRecord({
       key: this.createCacheKey(updatedBillingPortalDto.id),
@@ -113,7 +95,7 @@ var BaseBillingPortalService = class {
   async expireBillingPortalSession(idDto) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Expiring billing portal session',
+        "Expiring billing portal session",
         idDto
       );
     }
@@ -121,42 +103,18 @@ 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
-import { createCacheKey as createCacheKey2 } from '@forklaunch/core/cache';
-import { evaluateTelemetryOptions as evaluateTelemetryOptions2 } from '@forklaunch/core/http';
-import { transformIntoInternalMapper as transformIntoInternalMapper2 } from '@forklaunch/internal';
+import { createCacheKey as createCacheKey2 } from "@forklaunch/core/cache";
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions2
+} from "@forklaunch/core/http";
 var BaseCheckoutSessionService = class {
-  constructor(
-    em,
-    cache,
-    openTelemetryCollector,
-    schemaValidator,
-    mappers,
-    options
-  ) {
-    this.options = options;
-    this.em = em;
-    this.cache = cache;
-    this.openTelemetryCollector = openTelemetryCollector;
-    this.schemaValidator = schemaValidator;
-    this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper2(mappers, schemaValidator);
-    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? evaluateTelemetryOptions2(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
-  }
-  _mappers;
   evaluatedTelemetryOptions;
   enableDatabaseBackup;
   em;
@@ -164,23 +122,33 @@ var BaseCheckoutSessionService = class {
   openTelemetryCollector;
   schemaValidator;
   mappers;
-  createCacheKey = createCacheKey2('checkout_session');
-  async createCheckoutSession(checkoutSessionDto) {
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions2(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  createCacheKey = createCacheKey2("checkout_session");
+  async createCheckoutSession(checkoutSessionDto, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Creating checkout session',
+        "Creating checkout session",
         checkoutSessionDto
       );
     }
-    const checkoutSession =
-      await this._mappers.CreateCheckoutSessionMapper.deserializeDtoToEntity(
-        checkoutSessionDto,
-        this.em
-      );
-    const createdCheckoutSessionDto =
-      await this._mappers.CheckoutSessionMapper.serializeEntityToDto(
-        checkoutSession
-      );
+    const checkoutSession = await this.mappers.CreateCheckoutSessionMapper.toEntity(
+      checkoutSessionDto,
+      this.em,
+      ...args
+    );
+    const createdCheckoutSessionDto = await this.mappers.CheckoutSessionMapper.toDto(checkoutSession);
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(checkoutSession);
     }
@@ -191,14 +159,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.CheckoutSessionMapper.serializeEntityToDto(
+    return this.mappers.CheckoutSessionMapper.toDto(
       checkoutSessionDetails.value
     );
   }
@@ -207,18 +175,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);
     }
@@ -226,12 +194,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);
     }
@@ -240,35 +208,11 @@ var BaseCheckoutSessionService = class {
 };
 
 // services/paymentLink.service.ts
-import { createCacheKey as createCacheKey3 } from '@forklaunch/core/cache';
-import { evaluateTelemetryOptions as evaluateTelemetryOptions3 } from '@forklaunch/core/http';
-import { transformIntoInternalMapper as transformIntoInternalMapper3 } from '@forklaunch/internal';
+import { createCacheKey as createCacheKey3 } from "@forklaunch/core/cache";
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions3
+} from "@forklaunch/core/http";
 var BasePaymentLinkService = class {
-  constructor(
-    em,
-    cache,
-    openTelemetryCollector,
-    schemaValidator,
-    mappers,
-    options
-  ) {
-    this.options = options;
-    this.em = em;
-    this.cache = cache;
-    this.openTelemetryCollector = openTelemetryCollector;
-    this.schemaValidator = schemaValidator;
-    this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper3(mappers, schemaValidator);
-    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? evaluateTelemetryOptions3(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
-  }
-  _mappers;
   evaluatedTelemetryOptions;
   enableDatabaseBackup;
   em;
@@ -276,22 +220,34 @@ var BasePaymentLinkService = class {
   openTelemetryCollector;
   schemaValidator;
   mappers;
-  cacheKeyPrefix = 'payment_link';
+  constructor(em, cache, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.cache = cache;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions3(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
+  cacheKeyPrefix = "payment_link";
   createCacheKey = createCacheKey3(this.cacheKeyPrefix);
-  async createPaymentLink(paymentLinkDto) {
+  async createPaymentLink(paymentLinkDto, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Creating payment link', paymentLinkDto);
+      this.openTelemetryCollector.info("Creating payment link", paymentLinkDto);
     }
-    const paymentLink =
-      await this._mappers.CreatePaymentLinkMapper.deserializeDtoToEntity(
-        paymentLinkDto,
-        this.em
-      );
+    const paymentLink = await this.mappers.CreatePaymentLinkMapper.toEntity(
+      paymentLinkDto,
+      this.em,
+      ...args
+    );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(paymentLink);
     }
-    const createdPaymentLinkDto =
-      await this._mappers.PaymentLinkMapper.serializeEntityToDto(paymentLink);
+    const createdPaymentLinkDto = await this.mappers.PaymentLinkMapper.toDto(paymentLink);
     await this.cache.putRecord({
       key: this.createCacheKey(createdPaymentLinkDto.id),
       value: createdPaymentLinkDto,
@@ -299,28 +255,26 @@ var BasePaymentLinkService = class {
     });
     return createdPaymentLinkDto;
   }
-  async updatePaymentLink(paymentLinkDto) {
+  async updatePaymentLink(paymentLinkDto, ...args) {
     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.UpdatePaymentLinkMapper.deserializeDtoToEntity(
-        paymentLinkDto,
-        this.em
-      );
+    const paymentLink = await this.mappers.UpdatePaymentLinkMapper.toEntity(
+      paymentLinkDto,
+      this.em,
+      ...args
+    );
     if (this.enableDatabaseBackup) {
       await this.em.persistAndFlush(paymentLink);
     }
     const updatedLinkDto = {
       ...existingLink,
-      ...(await this._mappers.PaymentLinkMapper.serializeEntityToDto(
-        paymentLink
-      ))
+      ...await this.mappers.PaymentLinkMapper.toDto(paymentLink)
     };
     await this.cache.putRecord({
       key: cacheKey,
@@ -329,63 +283,62 @@ var BasePaymentLinkService = class {
     });
     return updatedLinkDto;
   }
-  async getPaymentLink({ id }) {
+  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);
+    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.PaymentLinkMapper.serializeEntityToDto(
-      paymentLink.value
-    );
+    return this.mappers.PaymentLinkMapper.toDto(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.PaymentLinkMapper.serializeEntityToDto(
-            paymentLink.value
-          );
+        const paymentLinkDto = this.mappers.PaymentLinkMapper.toDto(
+          paymentLink.value
+        );
         return paymentLinkDto;
       })
     );
@@ -393,89 +346,87 @@ var BasePaymentLinkService = class {
 };
 
 // services/plan.service.ts
-import { evaluateTelemetryOptions as evaluateTelemetryOptions4 } from '@forklaunch/core/http';
-import { transformIntoInternalMapper as transformIntoInternalMapper4 } from '@forklaunch/internal';
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions4
+} from "@forklaunch/core/http";
 var BasePlanService = class {
-  constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
-    this.options = options;
-    this.em = em;
-    this.openTelemetryCollector = openTelemetryCollector;
-    this.schemaValidator = schemaValidator;
-    this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper4(mappers, schemaValidator);
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? evaluateTelemetryOptions4(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
-  }
-  _mappers;
   evaluatedTelemetryOptions;
   em;
   openTelemetryCollector;
   schemaValidator;
   mappers;
+  constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
+    this.em = em;
+    this.openTelemetryCollector = openTelemetryCollector;
+    this.schemaValidator = schemaValidator;
+    this.mappers = mappers;
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions4(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
   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.PlanMapper.serializeEntityToDto(plan))
+      (await (em ?? this.em).findAll("Plan", {
+        filters: idsDto?.ids ? { id: { $in: idsDto.ids } } : void 0
+      })).map(
+        (plan) => this.mappers.PlanMapper.toDto(plan)
+      )
     );
   }
-  async createPlan(planDto, em) {
+  async createPlan(planDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Creating plan', planDto);
+      this.openTelemetryCollector.info("Creating plan", planDto);
     }
-    const plan = await this._mappers.CreatePlanMapper.deserializeDtoToEntity(
+    const plan = await this.mappers.CreatePlanMapper.toEntity(
       planDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(plan);
     });
-    return this._mappers.PlanMapper.serializeEntityToDto(plan);
+    return this.mappers.PlanMapper.toDto(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.PlanMapper.serializeEntityToDto(plan);
+    const plan = await (em ?? this.em).findOneOrFail("Plan", idDto);
+    return this.mappers.PlanMapper.toDto(plan);
   }
-  async updatePlan(planDto, em) {
+  async updatePlan(planDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Updating plan', planDto);
+      this.openTelemetryCollector.info("Updating plan", planDto);
     }
-    const plan = await this._mappers.UpdatePlanMapper.deserializeDtoToEntity(
+    const plan = await this.mappers.UpdatePlanMapper.toEntity(
       planDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
     const updatedPlan = await (em ?? this.em).upsert(plan);
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(plan);
     });
-    const updatedPlanDto =
-      await this._mappers.PlanMapper.serializeEntityToDto(updatedPlan);
+    const updatedPlanDto = await this.mappers.PlanMapper.toDto(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
-import { evaluateTelemetryOptions as evaluateTelemetryOptions5 } from '@forklaunch/core/http';
-import { transformIntoInternalMapper as transformIntoInternalMapper5 } from '@forklaunch/internal';
+import {
+  evaluateTelemetryOptions as evaluateTelemetryOptions5
+} from "@forklaunch/core/http";
 var BaseSubscriptionService = class {
   constructor(em, openTelemetryCollector, schemaValidator, mappers, options) {
     this.options = options;
@@ -483,132 +434,129 @@ var BaseSubscriptionService = class {
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper5(mappers, this.schemaValidator);
-    this.evaluatedTelemetryOptions = options?.telemetry
-      ? evaluateTelemetryOptions5(options.telemetry).enabled
-      : {
-          logging: false,
-          metrics: false,
-          tracing: false
-        };
-  }
-  _mappers;
+    this.evaluatedTelemetryOptions = options?.telemetry ? evaluateTelemetryOptions5(options.telemetry).enabled : {
+      logging: false,
+      metrics: false,
+      tracing: false
+    };
+  }
   evaluatedTelemetryOptions;
   em;
   openTelemetryCollector;
   schemaValidator;
   mappers;
-  async createSubscription(subscriptionDto, em) {
+  async createSubscription(subscriptionDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Creating subscription',
+        "Creating subscription",
         subscriptionDto
       );
     }
-    const subscription =
-      await this._mappers.CreateSubscriptionMapper.deserializeDtoToEntity(
-        subscriptionDto,
-        em ?? this.em
-      );
+    const subscription = await this.mappers.CreateSubscriptionMapper.toEntity(
+      subscriptionDto,
+      em ?? this.em,
+      ...args
+    );
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(subscription);
     });
-    const createdSubscriptionDto =
-      await this._mappers.SubscriptionMapper.serializeEntityToDto(subscription);
+    const createdSubscriptionDto = await this.mappers.SubscriptionMapper.toDto(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.SubscriptionMapper.serializeEntityToDto(subscription);
+    return this.mappers.SubscriptionMapper.toDto(
+      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.SubscriptionMapper.serializeEntityToDto(subscription);
+    return this.mappers.SubscriptionMapper.toDto(
+      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.SubscriptionMapper.serializeEntityToDto(subscription);
+    return this.mappers.SubscriptionMapper.toDto(
+      subscription
+    );
   }
-  async updateSubscription(subscriptionDto, em) {
+  async updateSubscription(subscriptionDto, em, ...args) {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info(
-        'Updating subscription',
+        "Updating subscription",
         subscriptionDto
       );
     }
-    const subscription =
-      this._mappers.UpdateSubscriptionMapper.deserializeDtoToEntity(
-        subscriptionDto,
-        em ?? this.em
-      );
+    const subscription = await this.mappers.UpdateSubscriptionMapper.toEntity(
+      subscriptionDto,
+      em ?? this.em,
+      ...args
+    );
     const updatedSubscription = await (em ?? this.em).upsert(subscription);
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(updatedSubscription);
     });
-    const updatedSubscriptionDto =
-      await this._mappers.SubscriptionMapper.serializeEntityToDto(
-        updatedSubscription
-      );
+    const updatedSubscriptionDto = await this.mappers.SubscriptionMapper.toDto(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.SubscriptionMapper.serializeEntityToDto(subscription);
+        const subscriptionDto = this.mappers.SubscriptionMapper.toDto(
+          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) => {
@@ -617,11 +565,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) => {