@forklaunch/implementation-billing-base 0.1.17 → 0.2.1

package/lib/eject/services/paymentLink.service.ts

@@ -1,15 +1,17 @@
 import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
 import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
+import {
+  evaluateTelemetryOptions,
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
 import {
   InternalDtoMapper,
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
 } from '@forklaunch/core/mappers';
-import {
-  MetricsDefinition,
-  OpenTelemetryCollector
-} from '@forklaunch/core/http';
 import { PaymentLinkService } from '@forklaunch/interfaces-billing/interfaces';
 import {
   CreatePaymentLinkDto,
@@ -17,42 +19,51 @@ import {
   UpdatePaymentLinkDto
 } from '@forklaunch/interfaces-billing/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
 
 export class BasePaymentLinkService<
   SchemaValidator extends AnySchemaValidator,
   CurrencyEnum,
+  StatusEnum,
   Metrics extends MetricsDefinition = MetricsDefinition,
   Dto extends {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
-    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum>;
-    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum>;
+    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
+    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum, StatusEnum>;
+    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum, StatusEnum>;
   } = {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
-    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum>;
-    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum>;
+    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
+    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum, StatusEnum>;
+    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum, StatusEnum>;
   },
   Entities extends {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
-    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
-    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
+    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
+    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
   } = {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
-    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
-    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
+    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
+    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
   }
-> implements PaymentLinkService<CurrencyEnum>
+> implements PaymentLinkService<CurrencyEnum, StatusEnum>
 {
-  #mapperss: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mapperss>,
+  #mappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mappers>,
     Entities,
     Dto
   >;
+  private evaluatedTelemetryOptions: {
+    logging?: boolean;
+    metrics?: boolean;
+    tracing?: boolean;
+  };
+  private enableDatabaseBackup: boolean;
 
   constructor(
+    protected readonly em: EntityManager,
     protected readonly cache: TtlCache,
     protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected readonly schemaValidator: SchemaValidator,
-    protected readonly mapperss: {
+    protected readonly mappers: {
       PaymentLinkDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['PaymentLinkDtoMapper'],
@@ -68,9 +79,21 @@ export class BasePaymentLinkService<
         Dto['UpdatePaymentLinkDtoMapper'],
         Entities['UpdatePaymentLinkDtoMapper']
       >;
+    },
+    readonly options?: {
+      enableDatabaseBackup?: boolean;
+      telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this.enableDatabaseBackup = options?.enableDatabaseBackup ?? false;
+    this.evaluatedTelemetryOptions = options?.telemetry
+      ? evaluateTelemetryOptions(options.telemetry).enabled
+      : {
+          logging: false,
+          metrics: false,
+          tracing: false
+        };
   }
 
   protected cacheKeyPrefix = 'payment_link';
@@ -79,48 +102,78 @@ export class BasePaymentLinkService<
   async createPaymentLink(
     paymentLinkDto: Dto['CreatePaymentLinkDtoMapper']
   ): Promise<Dto['PaymentLinkDtoMapper']> {
-    // TODO: Perform permission checks here
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Creating payment link', paymentLinkDto);
+    }
+
     const paymentLink =
-      this.#mapperss.CreatePaymentLinkDtoMapper.deserializeDtoToEntity(
-        paymentLinkDto
+      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(paymentLink.id),
-      value: paymentLink,
+      key: this.createCacheKey(createdPaymentLinkDto.id),
+      value: createdPaymentLinkDto,
       ttlMilliseconds: this.cache.getTtlMilliseconds()
     });
 
-    return this.#mapperss.PaymentLinkDtoMapper.serializeEntityToDto(
-      paymentLink
-    );
+    return createdPaymentLinkDto;
   }
 
   async updatePaymentLink(
     paymentLinkDto: Dto['UpdatePaymentLinkDtoMapper']
   ): Promise<Dto['PaymentLinkDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Updating payment link', paymentLinkDto);
+    }
+
     const cacheKey = this.createCacheKey(paymentLinkDto.id);
-    const existingLink =
-      await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(cacheKey);
+    const existingLink = (
+      await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(cacheKey)
+    )?.value;
     if (!existingLink) {
       throw new Error('Payment link not found');
     }
     const paymentLink =
-      this.#mapperss.UpdatePaymentLinkDtoMapper.deserializeDtoToEntity(
-        paymentLinkDto
+      await this.#mappers.UpdatePaymentLinkDtoMapper.deserializeDtoToEntity(
+        paymentLinkDto,
+        this.em
       );
-    const updatedLink = { ...existingLink, ...paymentLink };
+
+    if (this.enableDatabaseBackup) {
+      await this.em.persistAndFlush(paymentLink);
+    }
+
+    const updatedLinkDto = {
+      ...existingLink,
+      ...(await this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
+        paymentLink
+      ))
+    };
+
     await this.cache.putRecord({
       key: cacheKey,
-      value: updatedLink,
+      value: updatedLinkDto,
       ttlMilliseconds: this.cache.getTtlMilliseconds()
     });
 
-    return this.#mapperss.PaymentLinkDtoMapper.serializeEntityToDto(
-      updatedLink
-    );
+    return updatedLinkDto;
   }
 
   async getPaymentLink({ id }: IdDto): Promise<Dto['PaymentLinkDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Getting payment link', { id });
+    }
     const cacheKey = this.createCacheKey(id);
     const paymentLink =
       await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(cacheKey);
@@ -128,23 +181,45 @@ export class BasePaymentLinkService<
       throw new Error('Payment link not found');
     }
 
-    return this.#mapperss.PaymentLinkDtoMapper.serializeEntityToDto(
+    return this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
       paymentLink.value
     );
   }
 
   async expirePaymentLink({ id }: IdDto): Promise<void> {
     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 }: IdDto): Promise<void> {
     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 }: IdDto): Promise<void> {
     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));
   }
 
@@ -155,12 +230,12 @@ export class BasePaymentLinkService<
       idsDto?.ids.map((id) => this.createCacheKey(id)) ??
       (await this.cache.listKeys(this.cacheKeyPrefix));
 
-    return await Promise.all(
+    return Promise.all(
       keys.map(async (key) => {
         const paymentLink =
           await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(key);
         const paymentLinkDto =
-          this.#mapperss.PaymentLinkDtoMapper.serializeEntityToDto(
+          this.#mappers.PaymentLinkDtoMapper.serializeEntityToDto(
             paymentLink.value
           );
         return paymentLinkDto;

package/lib/eject/services/plan.service.ts

@@ -1,14 +1,16 @@
 import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  evaluateTelemetryOptions,
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
 import {
   InternalDtoMapper,
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
 } from '@forklaunch/core/mappers';
-import {
-  MetricsDefinition,
-  OpenTelemetryCollector
-} from '@forklaunch/core/http';
 import { PlanService } from '@forklaunch/interfaces-billing/interfaces';
 import {
   CreatePlanDto,
@@ -43,17 +45,22 @@ export class BasePlanService<
   }
 > implements PlanService<PlanCadenceEnum, BillingProviderEnum>
 {
-  #mapperss: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mapperss>,
+  #mappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mappers>,
     Entities,
     Dto
   >;
+  private evaluatedTelemetryOptions: {
+    logging?: boolean;
+    metrics?: boolean;
+    tracing?: boolean;
+  };
 
   constructor(
     private em: EntityManager,
     private readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     private readonly schemaValidator: SchemaValidator,
-    private readonly mapperss: {
+    private readonly mappers: {
       PlanDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['PlanDtoMapper'],
@@ -69,22 +76,37 @@ export class BasePlanService<
         Dto['UpdatePlanDtoMapper'],
         Entities['UpdatePlanDtoMapper']
       >;
+    },
+    readonly options?: {
+      telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry
+      ? evaluateTelemetryOptions(options.telemetry).enabled
+      : {
+          logging: false,
+          metrics: false,
+          tracing: false
+        };
   }
 
   async listPlans(
     idsDto?: IdsDto,
     em?: EntityManager
   ): Promise<Dto['PlanDtoMapper'][]> {
-    return (
-      await (em ?? this.em).findAll('Plan', {
-        filters: idsDto?.ids ? { id: { $in: idsDto.ids } } : undefined
-      })
-    ).map((plan) =>
-      this.#mapperss.PlanDtoMapper.serializeEntityToDto(
-        plan as Entities['PlanDtoMapper']
+    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 } } : undefined
+        })
+      ).map((plan) =>
+        this.#mappers.PlanDtoMapper.serializeEntityToDto(
+          plan as Entities['PlanDtoMapper']
+        )
       )
     );
   }
@@ -93,20 +115,28 @@ export class BasePlanService<
     planDto: Dto['CreatePlanDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['PlanDtoMapper']> {
-    const plan =
-      this.#mapperss.CreatePlanDtoMapper.deserializeDtoToEntity(planDto);
+    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.#mapperss.PlanDtoMapper.serializeEntityToDto(plan);
+    return this.#mappers.PlanDtoMapper.serializeEntityToDto(plan);
   }
 
   async getPlan(
     idDto: IdDto,
     em?: EntityManager
   ): Promise<Dto['PlanDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Getting plan', idDto);
+    }
     const plan = await (em ?? this.em).findOneOrFail('Plan', idDto);
-    return this.#mapperss.PlanDtoMapper.serializeEntityToDto(
+    return this.#mappers.PlanDtoMapper.serializeEntityToDto(
       plan as Entities['PlanDtoMapper']
     );
   }
@@ -115,18 +145,26 @@ export class BasePlanService<
     planDto: Dto['UpdatePlanDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['PlanDtoMapper']> {
-    const plan =
-      this.#mapperss.UpdatePlanDtoMapper.deserializeDtoToEntity(planDto);
+    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 =
-      this.#mapperss.PlanDtoMapper.serializeEntityToDto(updatedPlan);
+      await this.#mappers.PlanDtoMapper.serializeEntityToDto(updatedPlan);
     return updatedPlanDto;
   }
 
   async deletePlan(idDto: { id: string }, em?: EntityManager): Promise<void> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Deleting plan', idDto);
+    }
     await (em ?? this.em).nativeDelete('Plan', idDto);
   }
 }

package/lib/eject/services/subscription.service.ts

@@ -1,14 +1,16 @@
 import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  evaluateTelemetryOptions,
+  MetricsDefinition,
+  OpenTelemetryCollector,
+  TelemetryOptions
+} from '@forklaunch/core/http';
 import {
   InternalDtoMapper,
   RequestDtoMapperConstructor,
   ResponseDtoMapperConstructor,
   transformIntoInternalDtoMapper
 } from '@forklaunch/core/mappers';
-import {
-  MetricsDefinition,
-  OpenTelemetryCollector
-} from '@forklaunch/core/http';
 import { SubscriptionService } from '@forklaunch/interfaces-billing/interfaces';
 import {
   CreateSubscriptionDto,
@@ -67,17 +69,22 @@ export class BaseSubscriptionService<
   }
 > implements SubscriptionService<PartyType, BillingProviderType>
 {
-  #mapperss: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mapperss>,
+  #mappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mappers>,
     Entities,
     Dto
   >;
+  private evaluatedTelemetryOptions: {
+    logging?: boolean;
+    metrics?: boolean;
+    tracing?: boolean;
+  };
 
   constructor(
     protected em: EntityManager,
     protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected readonly schemaValidator: SchemaValidator,
-    protected readonly mapperss: {
+    protected readonly mappers: {
       SubscriptionDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['SubscriptionDtoMapper'],
@@ -93,29 +100,49 @@ export class BaseSubscriptionService<
         Dto['UpdateSubscriptionDtoMapper'],
         Entities['UpdateSubscriptionDtoMapper']
       >;
+    },
+    readonly options?: {
+      enableDatabaseBackup?: boolean;
+      telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mapperss = transformIntoInternalDtoMapper<
+    this.#mappers = transformIntoInternalDtoMapper<
       SchemaValidator,
-      typeof this.mapperss,
+      typeof this.mappers,
       Entities,
       Dto
-    >(mapperss, this.schemaValidator);
+    >(mappers, this.schemaValidator);
+    this.evaluatedTelemetryOptions = options?.telemetry
+      ? evaluateTelemetryOptions(options.telemetry).enabled
+      : {
+          logging: false,
+          metrics: false,
+          tracing: false
+        };
   }
 
   async createSubscription(
     subscriptionDto: Dto['CreateSubscriptionDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['SubscriptionDtoMapper']> {
-    const subscription =
-      this.#mapperss.CreateSubscriptionDtoMapper.deserializeDtoToEntity(
+    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 =
-      this.#mapperss.SubscriptionDtoMapper.serializeEntityToDto(subscription);
+      await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+        subscription
+      );
     return createdSubscriptionDto;
   }
 
@@ -123,11 +150,14 @@ export class BaseSubscriptionService<
     idDto: IdDto,
     em?: EntityManager
   ): Promise<Dto['SubscriptionDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Getting subscription', idDto);
+    }
     const subscription = await (em ?? this.em).findOneOrFail(
       'Subscription',
       idDto
     );
-    return this.#mapperss.SubscriptionDtoMapper.serializeEntityToDto(
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
       subscription as Entities['SubscriptionDtoMapper']
     );
   }
@@ -136,13 +166,16 @@ export class BaseSubscriptionService<
     { id }: IdDto,
     em?: EntityManager
   ): Promise<Dto['SubscriptionDtoMapper']> {
+    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.#mapperss.SubscriptionDtoMapper.serializeEntityToDto(
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
       subscription as Entities['SubscriptionDtoMapper']
     );
   }
@@ -151,12 +184,15 @@ export class BaseSubscriptionService<
     { id }: IdDto,
     em?: EntityManager
   ): Promise<Dto['SubscriptionDtoMapper']> {
+    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.#mapperss.SubscriptionDtoMapper.serializeEntityToDto(
+    return this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
       subscription as Entities['SubscriptionDtoMapper']
     );
   }
@@ -165,16 +201,23 @@ export class BaseSubscriptionService<
     subscriptionDto: Dto['UpdateSubscriptionDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['SubscriptionDtoMapper']> {
-    const subscription =
-      this.#mapperss.UpdateSubscriptionDtoMapper.deserializeDtoToEntity(
+    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 =
-      this.#mapperss.SubscriptionDtoMapper.serializeEntityToDto(
+      await this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
         updatedSubscription
       );
 
@@ -185,6 +228,9 @@ export class BaseSubscriptionService<
     idDto: { id: string },
     em?: EntityManager
   ): Promise<void> {
+    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');
@@ -196,6 +242,9 @@ export class BaseSubscriptionService<
     idsDto: { ids?: string[] },
     em?: EntityManager
   ): Promise<Dto['SubscriptionDtoMapper'][]> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Listing subscriptions', idsDto);
+    }
     const subscriptions = await (em ?? this.em).findAll('Subscription', {
       where: idsDto.ids
         ? {
@@ -206,16 +255,21 @@ export class BaseSubscriptionService<
         : undefined
     });
 
-    return subscriptions.map((subscription) => {
-      const subscriptionDto =
-        this.#mapperss.SubscriptionDtoMapper.serializeEntityToDto(
-          subscription as Entities['SubscriptionDtoMapper']
-        );
-      return subscriptionDto;
-    });
+    return Promise.all(
+      subscriptions.map((subscription) => {
+        const subscriptionDto =
+          this.#mappers.SubscriptionDtoMapper.serializeEntityToDto(
+            subscription as Entities['SubscriptionDtoMapper']
+          );
+        return subscriptionDto;
+      })
+    );
   }
 
   async cancelSubscription(idDto: IdDto, em?: EntityManager): Promise<void> {
+    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');
@@ -227,6 +281,9 @@ export class BaseSubscriptionService<
   }
 
   async resumeSubscription(idDto: IdDto, em?: EntityManager): Promise<void> {
+    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');