@forklaunch/implementation-billing-base 0.1.2 → 0.1.4

package/lib/__test__/schemaEquality.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemaEquality.test.d.ts.map

package/lib/__test__/schemaEquality.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaEquality.test.d.ts","sourceRoot":"","sources":["../../__test__/schemaEquality.test.ts"],"names":[],"mappings":""}

package/lib/__test__/schemaEquality.test.js

@@ -0,0 +1,226 @@
+import { isTrue } from '@forklaunch/common';
+import { DummyEnum, testSchemaEquality } from '@forklaunch/core/test';
+import { BillingPortalSchema as TypeboxBillingPortalSchema, CreateBillingPortalSchema as TypeboxCreateBillingPortalSchema, UpdateBillingPortalSchema as TypeboxUpdateBillingPortalSchema } from '../schemas/typebox/billingPortal.schema';
+import { CheckoutSessionSchema as TypeboxCheckoutSessionSchema, CreateCheckoutSessionSchema as TypeboxCreateCheckoutSessionSchema, UpdateCheckoutSessionSchema as TypeboxUpdateCheckoutSessionSchema } from '../schemas/typebox/checkoutSession.schema';
+import { CreatePaymentLinkSchema as TypeboxCreatePaymentLinkSchema, PaymentLinkSchema as TypeboxPaymentLinkSchema, UpdatePaymentLinkSchema as TypeboxUpdatePaymentLinkSchema } from '../schemas/typebox/paymentLink.schema';
+import { CreatePlanSchema as TypeboxCreatePlanSchema, PlanSchema as TypeboxPlanSchema, UpdatePlanSchema as TypeboxUpdatePlanSchema } from '../schemas/typebox/plan.schema';
+import { CreateSubscriptionSchema as TypeboxCreateSubscriptionSchema, SubscriptionSchema as TypeboxSubscriptionSchema, UpdateSubscriptionSchema as TypeboxUpdateSubscriptionSchema } from '../schemas/typebox/subscription.schema';
+import { BillingPortalSchema as ZodBillingPortalSchema, CreateBillingPortalSchema as ZodCreateBillingPortalSchema, UpdateBillingPortalSchema as ZodUpdateBillingPortalSchema } from '../schemas/zod/billingPortal.schema';
+import { CheckoutSessionSchema as ZodCheckoutSessionSchema, CreateCheckoutSessionSchema as ZodCreateCheckoutSessionSchema, UpdateCheckoutSessionSchema as ZodUpdateCheckoutSessionSchema } from '../schemas/zod/checkoutSession.schema';
+import { CreatePaymentLinkSchema as ZodCreatePaymentLinkSchema, PaymentLinkSchema as ZodPaymentLinkSchema, UpdatePaymentLinkSchema as ZodUpdatePaymentLinkSchema } from '../schemas/zod/paymentLink.schema';
+import { CreatePlanSchema as ZodCreatePlanSchema, PlanSchema as ZodPlanSchema, UpdatePlanSchema as ZodUpdatePlanSchema } from '../schemas/zod/plan.schema';
+import { CreateSubscriptionSchema as ZodCreateSubscriptionSchema, SubscriptionSchema as ZodSubscriptionSchema, UpdateSubscriptionSchema as ZodUpdateSubscriptionSchema } from '../schemas/zod/subscription.schema';
+const zodUpdateBillingPortalSchema = ZodUpdateBillingPortalSchema(false);
+const typeboxUpdateBillingPortalSchema = TypeboxUpdateBillingPortalSchema(false);
+const zodBillingPortalSchema = ZodBillingPortalSchema(false);
+const typeboxBillingPortalSchema = TypeboxBillingPortalSchema(false);
+const zodCreateCheckoutSessionSchema = ZodCreateCheckoutSessionSchema(DummyEnum);
+const typeboxCreateCheckoutSessionSchema = TypeboxCreateCheckoutSessionSchema(DummyEnum);
+const zodUpdateCheckoutSessionSchema = ZodUpdateCheckoutSessionSchema(false)(DummyEnum);
+const typeboxUpdateCheckoutSessionSchema = TypeboxUpdateCheckoutSessionSchema(false)(DummyEnum);
+const zodCheckoutSessionSchema = ZodCheckoutSessionSchema(false)(DummyEnum);
+const typeboxCheckoutSessionSchema = TypeboxCheckoutSessionSchema(false)(DummyEnum);
+const zodCreatePaymentLinkSchema = ZodCreatePaymentLinkSchema(DummyEnum);
+const typeboxCreatePaymentLinkSchema = TypeboxCreatePaymentLinkSchema(DummyEnum);
+const zodUpdatePaymentLinkSchema = ZodUpdatePaymentLinkSchema(false)(DummyEnum);
+const typeboxUpdatePaymentLinkSchema = TypeboxUpdatePaymentLinkSchema(false)(DummyEnum);
+const zodPaymentLinkSchema = ZodPaymentLinkSchema(false)(DummyEnum);
+const typeboxPaymentLinkSchema = TypeboxPaymentLinkSchema(false)(DummyEnum);
+const zodCreatePlanSchema = ZodCreatePlanSchema(DummyEnum, DummyEnum);
+const typeboxCreatePlanSchema = TypeboxCreatePlanSchema(DummyEnum, DummyEnum);
+const zodUpdatePlanSchema = ZodUpdatePlanSchema(false)(DummyEnum, DummyEnum);
+const typeboxUpdatePlanSchema = TypeboxUpdatePlanSchema(false)(DummyEnum, DummyEnum);
+const zodPlanSchema = ZodPlanSchema(false)(DummyEnum, DummyEnum);
+const typeboxPlanSchema = TypeboxPlanSchema(false)(DummyEnum, DummyEnum);
+const zodCreateSubscriptionSchema = ZodCreateSubscriptionSchema(DummyEnum, DummyEnum);
+const typeboxCreateSubscriptionSchema = TypeboxCreateSubscriptionSchema(DummyEnum, DummyEnum);
+const zodUpdateSubscriptionSchema = ZodUpdateSubscriptionSchema(false)(DummyEnum, DummyEnum);
+const typeboxUpdateSubscriptionSchema = TypeboxUpdateSubscriptionSchema(false)(DummyEnum, DummyEnum);
+const zodSubscriptionSchema = ZodSubscriptionSchema(false)(DummyEnum, DummyEnum);
+const typeboxSubscriptionSchema = TypeboxSubscriptionSchema(false)(DummyEnum, DummyEnum);
+describe('schema equality', () => {
+    it('should be equal for billing portal', () => {
+        expect(isTrue(testSchemaEquality(ZodCreateBillingPortalSchema, TypeboxCreateBillingPortalSchema, {
+            customerId: 'test',
+            uri: 'https://example.com',
+            expiresAt: new Date()
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdateBillingPortalSchema, typeboxUpdateBillingPortalSchema, {
+            id: 'test',
+            uri: 'https://example.com',
+            expiresAt: new Date()
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodBillingPortalSchema, typeboxBillingPortalSchema, {
+            id: 'test',
+            customerId: 'test',
+            uri: 'https://example.com',
+            expiresAt: new Date(),
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+    });
+    it('should be equal for checkout session', () => {
+        expect(isTrue(testSchemaEquality(zodCreateCheckoutSessionSchema, typeboxCreateCheckoutSessionSchema, {
+            customerId: 'test',
+            paymentMethods: [DummyEnum.A, DummyEnum.B],
+            successRedirectUri: 'https://example.com',
+            cancelRedirectUri: 'https://example.com',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdateCheckoutSessionSchema, typeboxUpdateCheckoutSessionSchema, {
+            id: 'test',
+            customerId: 'test',
+            paymentMethods: [DummyEnum.A, DummyEnum.B],
+            successRedirectUri: 'https://example.com',
+            cancelRedirectUri: 'https://example.com',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodCheckoutSessionSchema, typeboxCheckoutSessionSchema, {
+            id: 'test',
+            customerId: 'test',
+            paymentMethods: [DummyEnum.A, DummyEnum.B],
+            successRedirectUri: 'https://example.com',
+            cancelRedirectUri: 'https://example.com',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+    });
+    it('should be equal for payment link', () => {
+        expect(isTrue(testSchemaEquality(zodCreatePaymentLinkSchema, typeboxCreatePaymentLinkSchema, {
+            amount: 100,
+            currency: DummyEnum.A,
+            successRedirectUri: 'https://example.com',
+            cancelRedirectUri: 'https://example.com',
+            description: 'test',
+            metadata: {
+                test: 'test'
+            },
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdatePaymentLinkSchema, typeboxUpdatePaymentLinkSchema, {
+            id: 'test',
+            amount: 100,
+            currency: DummyEnum.A,
+            successRedirectUri: 'https://example.com',
+            cancelRedirectUri: 'https://example.com',
+            description: 'test',
+            metadata: {
+                test: 'test'
+            },
+            extraFields: {
+                test: 'test'
+            }
+        })));
+        expect(isTrue(testSchemaEquality(zodPaymentLinkSchema, typeboxPaymentLinkSchema, {
+            id: 'test',
+            amount: 100,
+            currency: DummyEnum.A,
+            successRedirectUri: 'https://example.com',
+            cancelRedirectUri: 'https://example.com',
+            description: 'test',
+            metadata: {
+                test: 'test'
+            },
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+    });
+    it('should be equal for plan', () => {
+        expect(isTrue(testSchemaEquality(zodCreatePlanSchema, typeboxCreatePlanSchema, {
+            name: 'test',
+            price: 100,
+            cadence: DummyEnum.A,
+            features: [DummyEnum.A, DummyEnum.B],
+            externalId: 'test',
+            active: true,
+            description: 'test',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdatePlanSchema, typeboxUpdatePlanSchema, {
+            id: 'test',
+            name: 'test',
+            price: 100,
+            cadence: DummyEnum.A,
+            features: [DummyEnum.A, DummyEnum.B],
+            externalId: 'test',
+            active: true,
+            description: 'test',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodPlanSchema, typeboxPlanSchema, {
+            id: 'test',
+            name: 'test',
+            price: 100,
+            cadence: DummyEnum.A,
+            features: [DummyEnum.A, DummyEnum.B],
+            externalId: 'test',
+            active: true,
+            description: 'test',
+            extraFields: {
+                test: 'test'
+            }
+        }))).toBeTruthy();
+    });
+    it('should be equal for subscription', () => {
+        expect(isTrue(testSchemaEquality(zodCreateSubscriptionSchema, typeboxCreateSubscriptionSchema, {
+            partyId: 'test',
+            partyType: DummyEnum.A,
+            productId: 'test',
+            status: DummyEnum.A,
+            active: true,
+            externalId: 'test',
+            startDate: new Date(),
+            endDate: new Date(),
+            description: 'test',
+            extraFields: {
+                test: 'test'
+            },
+            billingProvider: DummyEnum.A
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodUpdateSubscriptionSchema, typeboxUpdateSubscriptionSchema, {
+            id: 'test',
+            partyId: 'test',
+            partyType: DummyEnum.A,
+            productId: 'test',
+            status: DummyEnum.A,
+            active: true,
+            externalId: 'test',
+            startDate: new Date(),
+            endDate: new Date(),
+            description: 'test',
+            extraFields: {
+                test: 'test'
+            },
+            billingProvider: DummyEnum.A
+        }))).toBeTruthy();
+        expect(isTrue(testSchemaEquality(zodSubscriptionSchema, typeboxSubscriptionSchema, {
+            id: 'test',
+            partyId: 'test',
+            partyType: DummyEnum.A,
+            productId: 'test',
+            status: DummyEnum.A,
+            active: true,
+            externalId: 'test',
+            startDate: new Date(),
+            endDate: new Date(),
+            description: 'test',
+            extraFields: {
+                test: 'test'
+            },
+            billingProvider: DummyEnum.A
+        }))).toBeTruthy();
+    });
+});

package/{schemas/typebox → lib/eject/schemas/zod}/billingPortal.schema.ts

@@ -4,7 +4,7 @@ import {
   string,
   unknown,
   uuid
-} from '@forklaunch/validator/typebox';
+} from '@forklaunch/validator/zod';
 
 export const CreateBillingPortalSchema = {
   customerId: string,

package/{schemas/typebox → lib/eject/schemas/zod}/checkoutSession.schema.ts

@@ -7,7 +7,7 @@ import {
   string,
   unknown,
   uuid
-} from '@forklaunch/validator/typebox';
+} from '@forklaunch/validator/zod';
 
 export const CreateCheckoutSessionSchema = <
   T extends Record<string, LiteralSchema>
@@ -37,7 +37,6 @@ export const CheckoutSessionSchema =
   <T extends Record<string, LiteralSchema>>(PaymentMethodEnum: T) => ({
     id: uuidId ? uuid : string,
     customerId: string,
-    metadata: optional(unknown),
     paymentMethods: array(enum_(PaymentMethodEnum)),
     successRedirectUri: string,
     cancelRedirectUri: string,

package/{schemas/typebox → lib/eject/schemas/zod}/paymentLink.schema.ts

@@ -7,7 +7,7 @@ import {
   string,
   unknown,
   uuid
-} from '@forklaunch/validator/typebox';
+} from '@forklaunch/validator/zod';
 
 export const CreatePaymentLinkSchema = <
   T extends Record<string, LiteralSchema>

package/{schemas/typebox → lib/eject/schemas/zod}/plan.schema.ts

@@ -9,7 +9,7 @@ import {
   string,
   unknown,
   uuid
-} from '@forklaunch/validator/typebox';
+} from '@forklaunch/validator/zod';
 
 export const CreatePlanSchema = <
   T extends Record<string, LiteralSchema>,

package/{schemas/typebox → lib/eject/schemas/zod}/subscription.schema.ts

@@ -7,7 +7,7 @@ import {
   string,
   unknown,
   uuid
-} from '@forklaunch/validator/typebox';
+} from '@forklaunch/validator/zod';
 
 export const CreateSubscriptionSchema = <
   T extends Record<string, LiteralSchema>,

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

@@ -0,0 +1,148 @@
+import {
+  BillingPortalDto,
+  BillingPortalService,
+  CreateBillingPortalDto,
+  UpdateBillingPortalDto
+} from '@forklaunch/interfaces-billing';
+import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
+import {
+  InternalDtoMapper,
+  RequestDtoMapperConstructor,
+  ResponseDtoMapperConstructor,
+  transformIntoInternalDtoMapper
+} from '@forklaunch/core/dtoMapper';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector
+} from '@forklaunch/core/http';
+import { AnySchemaValidator } from '@forklaunch/validator';
+
+export class BaseBillingPortalService<
+  SchemaValidator extends AnySchemaValidator,
+  Metrics extends MetricsDefinition = MetricsDefinition,
+  Dto extends {
+    BillingPortalDtoMapper: BillingPortalDto;
+    CreateBillingPortalDtoMapper: CreateBillingPortalDto;
+    UpdateBillingPortalDtoMapper: UpdateBillingPortalDto;
+  } = {
+    BillingPortalDtoMapper: BillingPortalDto;
+    CreateBillingPortalDtoMapper: CreateBillingPortalDto;
+    UpdateBillingPortalDtoMapper: UpdateBillingPortalDto;
+  },
+  Entities extends {
+    BillingPortalDtoMapper: BillingPortalDto;
+    CreateBillingPortalDtoMapper: BillingPortalDto;
+    UpdateBillingPortalDtoMapper: BillingPortalDto;
+  } = {
+    BillingPortalDtoMapper: BillingPortalDto;
+    CreateBillingPortalDtoMapper: BillingPortalDto;
+    UpdateBillingPortalDtoMapper: BillingPortalDto;
+  }
+> implements BillingPortalService
+{
+  #dtoMappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.dtoMappers>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    protected cache: TtlCache,
+    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected schemaValidator: SchemaValidator,
+    protected dtoMappers: {
+      BillingPortalDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['BillingPortalDtoMapper'],
+        Entities['BillingPortalDtoMapper']
+      >;
+      CreateBillingPortalDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateBillingPortalDtoMapper'],
+        Entities['CreateBillingPortalDtoMapper']
+      >;
+      UpdateBillingPortalDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateBillingPortalDtoMapper'],
+        Entities['UpdateBillingPortalDtoMapper']
+      >;
+    }
+  ) {
+    this.#dtoMappers = transformIntoInternalDtoMapper(
+      dtoMappers,
+      schemaValidator
+    );
+  }
+
+  protected createCacheKey = createCacheKey('billing_portal_session');
+
+  async createBillingPortalSession(
+    billingPortalDto: Dto['CreateBillingPortalDtoMapper']
+  ): Promise<Dto['BillingPortalDtoMapper']> {
+    const billingPortalSession =
+      this.#dtoMappers.CreateBillingPortalDtoMapper.deserializeDtoToEntity(
+        billingPortalDto
+      );
+
+    this.openTelemetryCollector.debug(
+      'Create billing portal session',
+      billingPortalSession
+    );
+
+    await this.cache.putRecord({
+      key: this.createCacheKey(billingPortalSession.id),
+      value: billingPortalSession,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+
+    return this.#dtoMappers.BillingPortalDtoMapper.serializeEntityToDto(
+      billingPortalSession
+    );
+  }
+
+  async getBillingPortalSession(
+    idDto: IdDto
+  ): Promise<Dto['BillingPortalDtoMapper']> {
+    const billingPortalSessionDetails = await this.cache.readRecord<
+      Entities['BillingPortalDtoMapper']
+    >(this.createCacheKey(idDto.id));
+    if (!billingPortalSessionDetails) {
+      throw new Error('Session not found');
+    }
+
+    return this.#dtoMappers.BillingPortalDtoMapper.serializeEntityToDto(
+      billingPortalSessionDetails.value
+    );
+  }
+
+  async updateBillingPortalSession(
+    billingPortalDto: UpdateBillingPortalDto
+  ): Promise<Dto['BillingPortalDtoMapper']> {
+    const billingPortalSession =
+      this.#dtoMappers.UpdateBillingPortalDtoMapper.deserializeDtoToEntity(
+        billingPortalDto
+      );
+    // Save the updated session to your database or external service
+    await this.cache.putRecord({
+      key: this.createCacheKey(billingPortalSession.id),
+      value: billingPortalSession,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+
+    return this.#dtoMappers.BillingPortalDtoMapper.serializeEntityToDto(
+      billingPortalSession
+    );
+  }
+
+  async expireBillingPortalSession(idDto: IdDto): Promise<void> {
+    const sessionExists = await this.cache.readRecord(
+      this.createCacheKey(idDto.id)
+    );
+    if (!sessionExists) {
+      throw new Error('Session not found');
+    }
+
+    await this.cache.deleteRecord(this.createCacheKey(idDto.id));
+  }
+}

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

@@ -0,0 +1,135 @@
+import {
+  CheckoutSessionDto,
+  CheckoutSessionService,
+  CreateCheckoutSessionDto,
+  UpdateCheckoutSessionDto
+} from '@forklaunch/interfaces-billing';
+import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
+import {
+  InternalDtoMapper,
+  RequestDtoMapperConstructor,
+  ResponseDtoMapperConstructor,
+  transformIntoInternalDtoMapper
+} from '@forklaunch/core/dtoMapper';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector
+} from '@forklaunch/core/http';
+import { AnySchemaValidator } from '@forklaunch/validator';
+
+export class BaseCheckoutSessionService<
+  SchemaValidator extends AnySchemaValidator,
+  PaymentMethodEnum,
+  Metrics extends MetricsDefinition = MetricsDefinition,
+  Dto extends {
+    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<PaymentMethodEnum>;
+    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<PaymentMethodEnum>;
+  } = {
+    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<PaymentMethodEnum>;
+    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<PaymentMethodEnum>;
+  },
+  Entities extends {
+    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+  } = {
+    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum>;
+  }
+> implements CheckoutSessionService<PaymentMethodEnum>
+{
+  #dtoMappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.dtoMappers>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    protected readonly cache: TtlCache,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected readonly schemaValidator: SchemaValidator,
+    protected readonly dtoMappers: {
+      CheckoutSessionDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CheckoutSessionDtoMapper'],
+        Entities['CheckoutSessionDtoMapper']
+      >;
+      CreateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateCheckoutSessionDtoMapper'],
+        Entities['CreateCheckoutSessionDtoMapper']
+      >;
+      UpdateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateCheckoutSessionDtoMapper'],
+        Entities['UpdateCheckoutSessionDtoMapper']
+      >;
+    }
+  ) {
+    this.#dtoMappers = transformIntoInternalDtoMapper(
+      dtoMappers,
+      schemaValidator
+    );
+  }
+
+  protected createCacheKey = createCacheKey('checkout_session');
+
+  async createCheckoutSession(
+    checkoutSessionDto: Dto['CreateCheckoutSessionDtoMapper']
+  ): Promise<Dto['CheckoutSessionDtoMapper']> {
+    const checkoutSession =
+      this.#dtoMappers.CreateCheckoutSessionDtoMapper.deserializeDtoToEntity(
+        checkoutSessionDto
+      );
+
+    // Store the checkoutSession details in the cache
+    await this.cache.putRecord({
+      key: this.createCacheKey(checkoutSession.id),
+      value: checkoutSession,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+
+    return this.#dtoMappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+      checkoutSession
+    );
+  }
+
+  async getCheckoutSession({
+    id
+  }: IdDto): Promise<Dto['CheckoutSessionDtoMapper']> {
+    const checkoutSessionDetails = await this.cache.readRecord<
+      Entities['CheckoutSessionDtoMapper']
+    >(this.createCacheKey(id));
+    if (!checkoutSessionDetails) {
+      throw new Error('Session not found');
+    }
+
+    return this.#dtoMappers.CheckoutSessionDtoMapper.serializeEntityToDto(
+      checkoutSessionDetails.value
+    );
+  }
+
+  async expireCheckoutSession({ id }: IdDto): Promise<void> {
+    const checkoutSessionDetails = await this.cache.readRecord(
+      this.createCacheKey(id)
+    );
+    if (!checkoutSessionDetails) {
+      throw new Error('Session not found');
+    }
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+
+  async handleCheckoutSuccess({ id }: IdDto): Promise<void> {
+    this.openTelemetryCollector.info('Checkout success', { id });
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+
+  async handleCheckoutFailure({ id }: IdDto): Promise<void> {
+    this.openTelemetryCollector.info('Checkout failure', { id });
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+}