@forklaunch/implementation-billing-base 0.1.17 → 0.2.1

package/lib/__test__/schemaEquality.test.js

@@ -60,35 +60,48 @@ const zodBillingPortalSchema = ZodBillingPortalSchema({ uuidId: false });
 const typeboxBillingPortalSchema = TypeboxBillingPortalSchema({
   uuidId: false
 });
-const zodCreateCheckoutSessionSchema =
-  ZodCreateCheckoutSessionSchema(DummyEnum);
-const typeboxCreateCheckoutSessionSchema =
-  TypeboxCreateCheckoutSessionSchema(DummyEnum);
+const zodCreateCheckoutSessionSchema = ZodCreateCheckoutSessionSchema(
+  DummyEnum,
+  DummyEnum
+);
+const typeboxCreateCheckoutSessionSchema = TypeboxCreateCheckoutSessionSchema(
+  DummyEnum,
+  DummyEnum
+);
 const zodUpdateCheckoutSessionSchema = ZodUpdateCheckoutSessionSchema({
   uuidId: false
-})(DummyEnum);
+})(DummyEnum, DummyEnum);
 const typeboxUpdateCheckoutSessionSchema = TypeboxUpdateCheckoutSessionSchema({
   uuidId: false
-})(DummyEnum);
+})(DummyEnum, DummyEnum);
 const zodCheckoutSessionSchema = ZodCheckoutSessionSchema({ uuidId: true })(
+  DummyEnum,
   DummyEnum
 );
 const typeboxCheckoutSessionSchema = TypeboxCheckoutSessionSchema({
   uuidId: true
-})(DummyEnum);
-const zodCreatePaymentLinkSchema = ZodCreatePaymentLinkSchema(DummyEnum);
-const typeboxCreatePaymentLinkSchema =
-  TypeboxCreatePaymentLinkSchema(DummyEnum);
+})(DummyEnum, DummyEnum);
+const zodCreatePaymentLinkSchema = ZodCreatePaymentLinkSchema(
+  DummyEnum,
+  DummyEnum
+);
+const typeboxCreatePaymentLinkSchema = TypeboxCreatePaymentLinkSchema(
+  DummyEnum,
+  DummyEnum
+);
 const zodUpdatePaymentLinkSchema = ZodUpdatePaymentLinkSchema({
   uuidId: false
-})(DummyEnum);
+})(DummyEnum, DummyEnum);
 const typeboxUpdatePaymentLinkSchema = TypeboxUpdatePaymentLinkSchema({
   uuidId: false
-})(DummyEnum);
-const zodPaymentLinkSchema = ZodPaymentLinkSchema({ uuidId: true })(DummyEnum);
+})(DummyEnum, DummyEnum);
+const zodPaymentLinkSchema = ZodPaymentLinkSchema({ uuidId: true })(
+  DummyEnum,
+  DummyEnum
+);
 const typeboxPaymentLinkSchema = TypeboxPaymentLinkSchema({
   uuidId: false
-})(DummyEnum);
+})(DummyEnum, DummyEnum);
 const zodCreatePlanSchema = ZodCreatePlanSchema(DummyEnum, DummyEnum);
 const typeboxCreatePlanSchema = TypeboxCreatePlanSchema(DummyEnum, DummyEnum);
 const zodUpdatePlanSchema = ZodUpdatePlanSchema({ uuidId: false })(
@@ -178,6 +191,8 @@ describe('schema equality', () => {
             paymentMethods: [DummyEnum.A, DummyEnum.B],
             successRedirectUri: 'https://example.com',
             cancelRedirectUri: 'https://example.com',
+            expiresAt: new Date(),
+            status: DummyEnum.A,
             extraFields: {
               test: 'test'
             }
@@ -214,6 +229,8 @@ describe('schema equality', () => {
             paymentMethods: [DummyEnum.A, DummyEnum.B],
             successRedirectUri: 'https://example.com',
             cancelRedirectUri: 'https://example.com',
+            expiresAt: new Date(),
+            status: DummyEnum.A,
             extraFields: {
               test: 'test'
             }
@@ -237,6 +254,8 @@ describe('schema equality', () => {
             metadata: {
               test: 'test'
             },
+            expiresAt: new Date(),
+            status: DummyEnum.A,
             extraFields: {
               test: 'test'
             }
@@ -278,6 +297,8 @@ describe('schema equality', () => {
           metadata: {
             test: 'test'
           },
+          expiresAt: new Date(),
+          status: DummyEnum.A,
           extraFields: {
             test: 'test'
           }

package/lib/eject/domain/schemas/checkoutSession.schema.ts

@@ -10,37 +10,57 @@ import {
 } from '@{{app_name}}/core';
 
 export const CreateCheckoutSessionSchema = <
-  T extends Record<string, LiteralSchema>
+  T extends Record<string, LiteralSchema>,
+  U extends Record<string, LiteralSchema>
 >(
-  PaymentMethodEnum: T
+  PaymentMethodEnum: T,
+  StatusEnum: U
 ) => ({
   customerId: string,
   paymentMethods: array(enum_(PaymentMethodEnum)),
   successRedirectUri: string,
   cancelRedirectUri: string,
+  expiresAt: date,
+  status: enum_(StatusEnum),
   extraFields: optional(unknown)
 });
 
 export const UpdateCheckoutSessionSchema =
   ({ uuidId }: { uuidId: boolean }) =>
-  <T extends Record<string, LiteralSchema>>(PaymentMethodEnum: T) => ({
+  <
+    T extends Record<string, LiteralSchema>,
+    U extends Record<string, LiteralSchema>
+  >(
+    PaymentMethodEnum: T,
+    StatusEnum: U
+  ) => ({
     id: uuidId ? uuid : string,
     customerId: optional(string),
     paymentMethods: optional(array(enum_(PaymentMethodEnum))),
     successRedirectUri: optional(string),
     cancelRedirectUri: optional(string),
+    expiresAt: optional(date),
+    status: optional(enum_(StatusEnum)),
     extraFields: optional(unknown)
   });
 
 export const CheckoutSessionSchema =
   ({ uuidId }: { uuidId: boolean }) =>
-  <T extends Record<string, LiteralSchema>>(PaymentMethodEnum: T) => ({
+  <
+    T extends Record<string, LiteralSchema>,
+    U extends Record<string, LiteralSchema>
+  >(
+    PaymentMethodEnum: T,
+    StatusEnum: U
+  ) => ({
     id: uuidId ? uuid : string,
     customerId: string,
     metadata: optional(unknown),
     paymentMethods: array(enum_(PaymentMethodEnum)),
     successRedirectUri: string,
     cancelRedirectUri: string,
+    expiresAt: date,
+    status: enum_(StatusEnum),
     extraFields: optional(unknown),
     createdAt: optional(date),
     updatedAt: optional(date)

package/lib/eject/domain/schemas/paymentLink.schema.ts

@@ -10,9 +10,11 @@ import {
 } from '@{{app_name}}/core';
 
 export const CreatePaymentLinkSchema = <
-  T extends Record<string, LiteralSchema>
+  T extends Record<string, LiteralSchema>,
+  U extends Record<string, LiteralSchema>
 >(
-  CurrencyEnum: T
+  CurrencyEnum: T,
+  StatusEnum: U
 ) => ({
   amount: number,
   currency: enum_(CurrencyEnum),
@@ -20,12 +22,20 @@ export const CreatePaymentLinkSchema = <
   metadata: optional(unknown),
   successRedirectUri: string,
   cancelRedirectUri: string,
+  expiresAt: date,
+  status: enum_(StatusEnum),
   extraFields: optional(unknown)
 });
 
 export const UpdatePaymentLinkSchema =
   ({ uuidId }: { uuidId: boolean }) =>
-  <T extends Record<string, LiteralSchema>>(CurrencyEnum: T) => ({
+  <
+    T extends Record<string, LiteralSchema>,
+    U extends Record<string, LiteralSchema>
+  >(
+    CurrencyEnum: T,
+    StatusEnum: U
+  ) => ({
     id: uuidId ? uuid : string,
     amount: optional(number),
     currency: optional(enum_(CurrencyEnum)),
@@ -33,12 +43,20 @@ export const UpdatePaymentLinkSchema =
     metadata: optional(unknown),
     successRedirectUri: optional(string),
     cancelRedirectUri: optional(string),
+    expiresAt: optional(date),
+    status: optional(enum_(StatusEnum)),
     extraFields: optional(unknown)
   });
 
 export const PaymentLinkSchema =
   ({ uuidId }: { uuidId: boolean }) =>
-  <T extends Record<string, LiteralSchema>>(CurrencyEnum: T) => ({
+  <
+    T extends Record<string, LiteralSchema>,
+    U extends Record<string, LiteralSchema>
+  >(
+    CurrencyEnum: T,
+    StatusEnum: U
+  ) => ({
     id: uuidId ? uuid : string,
     amount: number,
     currency: enum_(CurrencyEnum),
@@ -46,6 +64,8 @@ export const PaymentLinkSchema =
     metadata: optional(unknown),
     successRedirectUri: string,
     cancelRedirectUri: string,
+    expiresAt: date,
+    status: enum_(StatusEnum),
     extraFields: optional(unknown),
     createdAt: optional(date),
     updatedAt: optional(date)

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

@@ -1,15 +1,17 @@
 import { IdDto, 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 { BillingPortalService } from '@forklaunch/interfaces-billing/interfaces';
 import {
   BillingPortalDto,
@@ -17,6 +19,7 @@ import {
   UpdateBillingPortalDto
 } from '@forklaunch/interfaces-billing/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
 
 export class BaseBillingPortalService<
   SchemaValidator extends AnySchemaValidator,
@@ -41,17 +44,24 @@ export class BaseBillingPortalService<
   }
 > implements BillingPortalService
 {
-  #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 em: EntityManager,
     protected cache: TtlCache,
     protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
     protected schemaValidator: SchemaValidator,
-    protected mapperss: {
+    protected mappers: {
       BillingPortalDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['BillingPortalDtoMapper'],
@@ -67,9 +77,21 @@ export class BaseBillingPortalService<
         Dto['UpdateBillingPortalDtoMapper'],
         Entities['UpdateBillingPortalDtoMapper']
       >;
+    },
+    readonly options?: {
+      telemetry?: TelemetryOptions;
+      enableDatabaseBackup?: boolean;
     }
   ) {
-    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 createCacheKey = createCacheKey('billing_portal_session');
@@ -77,65 +99,115 @@ export class BaseBillingPortalService<
   async createBillingPortalSession(
     billingPortalDto: Dto['CreateBillingPortalDtoMapper']
   ): Promise<Dto['BillingPortalDtoMapper']> {
-    const billingPortalSession =
-      this.#mapperss.CreateBillingPortalDtoMapper.deserializeDtoToEntity(
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Creating billing portal session',
         billingPortalDto
       );
+    }
 
-    this.openTelemetryCollector.debug(
-      'Create billing portal session',
-      billingPortalSession
-    );
+    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(billingPortalSession.id),
-      value: billingPortalSession,
+      key: this.createCacheKey(createdBillingPortalDto.id),
+      value: createdBillingPortalDto,
       ttlMilliseconds: this.cache.getTtlMilliseconds()
     });
 
-    return this.#mapperss.BillingPortalDtoMapper.serializeEntityToDto(
-      billingPortalSession
-    );
+    return createdBillingPortalDto;
   }
 
   async getBillingPortalSession(
     idDto: IdDto
   ): Promise<Dto['BillingPortalDtoMapper']> {
-    const billingPortalSessionDetails = await this.cache.readRecord<
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Getting billing portal session', idDto);
+    }
+
+    const billingPortalDetails = await this.cache.readRecord<
       Entities['BillingPortalDtoMapper']
     >(this.createCacheKey(idDto.id));
-    if (!billingPortalSessionDetails) {
+
+    if (!billingPortalDetails) {
       throw new Error('Session not found');
     }
 
-    return this.#mapperss.BillingPortalDtoMapper.serializeEntityToDto(
-      billingPortalSessionDetails.value
-    );
+    return billingPortalDetails.value;
   }
 
   async updateBillingPortalSession(
     billingPortalDto: UpdateBillingPortalDto
   ): Promise<Dto['BillingPortalDtoMapper']> {
-    const billingPortalSession =
-      this.#mapperss.UpdateBillingPortalDtoMapper.deserializeDtoToEntity(
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Updating billing portal session',
         billingPortalDto
       );
-    // Save the updated session to your database or external service
+    }
+
+    const existingBillingPortal = (
+      await this.cache.readRecord<Entities['BillingPortalDtoMapper']>(
+        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(billingPortalSession.id),
-      value: billingPortalSession,
+      key: this.createCacheKey(updatedBillingPortalDto.id),
+      value: updatedBillingPortalDto,
       ttlMilliseconds: this.cache.getTtlMilliseconds()
     });
 
-    return this.#mapperss.BillingPortalDtoMapper.serializeEntityToDto(
-      billingPortalSession
-    );
+    return updatedBillingPortalDto;
   }
 
   async expireBillingPortalSession(idDto: IdDto): Promise<void> {
+    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');
     }

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

@@ -1,15 +1,17 @@
 import { IdDto, 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 { CheckoutSessionService } from '@forklaunch/interfaces-billing/interfaces';
 import {
   CheckoutSessionDto,
@@ -17,42 +19,75 @@ import {
   UpdateCheckoutSessionDto
 } from '@forklaunch/interfaces-billing/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
 
 export class BaseCheckoutSessionService<
   SchemaValidator extends AnySchemaValidator,
   PaymentMethodEnum,
+  StatusEnum,
   Metrics extends MetricsDefinition = MetricsDefinition,
   Dto extends {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
-    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<PaymentMethodEnum>;
-    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<PaymentMethodEnum>;
+    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
+    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<
+      PaymentMethodEnum,
+      StatusEnum
+    >;
+    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<
+      PaymentMethodEnum,
+      StatusEnum
+    >;
   } = {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
-    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<PaymentMethodEnum>;
-    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<PaymentMethodEnum>;
+    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
+    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<
+      PaymentMethodEnum,
+      StatusEnum
+    >;
+    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<
+      PaymentMethodEnum,
+      StatusEnum
+    >;
   },
   Entities extends {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
-    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
-    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
+    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<
+      PaymentMethodEnum,
+      StatusEnum
+    >;
+    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<
+      PaymentMethodEnum,
+      StatusEnum
+    >;
   } = {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
-    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
-    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
+    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<
+      PaymentMethodEnum,
+      StatusEnum
+    >;
+    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<
+      PaymentMethodEnum,
+      StatusEnum
+    >;
   }
-> implements CheckoutSessionService<PaymentMethodEnum>
+> implements CheckoutSessionService<PaymentMethodEnum, 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: {
       CheckoutSessionDtoMapper: ResponseDtoMapperConstructor<
         SchemaValidator,
         Dto['CheckoutSessionDtoMapper'],
@@ -68,9 +103,21 @@ export class BaseCheckoutSessionService<
         Dto['UpdateCheckoutSessionDtoMapper'],
         Entities['UpdateCheckoutSessionDtoMapper']
       >;
+    },
+    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 createCacheKey = createCacheKey('checkout_session');
@@ -78,21 +125,35 @@ export class BaseCheckoutSessionService<
   async createCheckoutSession(
     checkoutSessionDto: Dto['CreateCheckoutSessionDtoMapper']
   ): Promise<Dto['CheckoutSessionDtoMapper']> {
-    const checkoutSession =
-      this.#mapperss.CreateCheckoutSessionDtoMapper.deserializeDtoToEntity(
+    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);
+    }
 
-    // Store the checkoutSession details in the cache
     await this.cache.putRecord({
-      key: this.createCacheKey(checkoutSession.id),
-      value: checkoutSession,
+      key: this.createCacheKey(createdCheckoutSessionDto.id),
+      value: createdCheckoutSessionDto,
       ttlMilliseconds: this.cache.getTtlMilliseconds()
     });
 
-    return this.#mapperss.CheckoutSessionDtoMapper.serializeEntityToDto(
-      checkoutSession
-    );
+    return createdCheckoutSessionDto;
   }
 
   async getCheckoutSession({
@@ -105,7 +166,7 @@ export class BaseCheckoutSessionService<
       throw new Error('Session not found');
     }
 
-    return this.#mapperss.CheckoutSessionDtoMapper.serializeEntityToDto(
+    return this.#mappers.CheckoutSessionDtoMapper.serializeEntityToDto(
       checkoutSessionDetails.value
     );
   }
@@ -121,12 +182,34 @@ export class BaseCheckoutSessionService<
   }
 
   async handleCheckoutSuccess({ id }: IdDto): Promise<void> {
-    this.openTelemetryCollector.info('Checkout success', { 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 }: IdDto): Promise<void> {
-    this.openTelemetryCollector.info('Checkout failure', { 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));
   }
 }