@forklaunch/implementation-billing-base 0.1.12 → 0.1.14

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

@@ -0,0 +1,86 @@
+import { LiteralSchema } from '@forklaunch/validator';
+import {
+  boolean,
+  date,
+  enum_,
+  optional,
+  string,
+  unknown,
+  uuid
+} from '@{{app_name}}/core';
+
+export const CreateSubscriptionSchema = <
+  T extends Record<string, LiteralSchema>,
+  U extends Record<string, LiteralSchema>
+>(
+  PartyEnum: T,
+  BillingProviderEnum: U
+) => ({
+  partyId: string,
+  partyType: enum_(PartyEnum),
+  productId: string,
+  description: optional(string),
+  active: boolean,
+  externalId: string,
+  startDate: date,
+  endDate: date,
+  status: string,
+  billingProvider: optional(enum_(BillingProviderEnum)),
+  extraFields: optional(unknown)
+});
+
+export const UpdateSubscriptionSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <
+    T extends Record<string, LiteralSchema>,
+    U extends Record<string, LiteralSchema>
+  >(
+    PartyEnum: T,
+    BillingProviderEnum: U
+  ) => ({
+    id: uuidId ? uuid : string,
+    partyId: optional(string),
+    partyType: optional(enum_(PartyEnum)),
+    productId: optional(string),
+    description: optional(string),
+    active: optional(boolean),
+    externalId: optional(string),
+    startDate: optional(date),
+    endDate: optional(date),
+    status: optional(string),
+    billingProvider: optional(enum_(BillingProviderEnum)),
+    extraFields: optional(unknown)
+  });
+
+export const SubscriptionSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <
+    T extends Record<string, LiteralSchema>,
+    U extends Record<string, LiteralSchema>
+  >(
+    PartyEnum: T,
+    BillingProviderEnum: U
+  ) => ({
+    id: uuidId ? uuid : string,
+    partyId: string,
+    partyType: enum_(PartyEnum),
+    productId: string,
+    description: optional(string),
+    active: boolean,
+    externalId: string,
+    startDate: date,
+    endDate: date,
+    status: string,
+    billingProvider: optional(enum_(BillingProviderEnum)),
+    extraFields: optional(unknown),
+    createdAt: optional(date),
+    updatedAt: optional(date)
+  });
+
+export const BaseSubscriptionServiceSchemas = (options: {
+  uuidId: boolean;
+}) => ({
+  CreateSubscriptionSchema,
+  UpdateSubscriptionSchema: UpdateSubscriptionSchema(options),
+  SubscriptionSchema: SubscriptionSchema(options)
+});

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

@@ -0,0 +1,145 @@
+import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
+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,
+  CreateBillingPortalDto,
+  UpdateBillingPortalDto
+} from '@forklaunch/interfaces-billing/types';
+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
+{
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    protected cache: TtlCache,
+    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected schemaValidator: SchemaValidator,
+    protected mapperss: {
+      BillingPortalDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['BillingPortalDtoMapper'],
+        Entities['BillingPortalDtoMapper']
+      >;
+      CreateBillingPortalDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateBillingPortalDtoMapper'],
+        Entities['CreateBillingPortalDtoMapper']
+      >;
+      UpdateBillingPortalDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateBillingPortalDtoMapper'],
+        Entities['UpdateBillingPortalDtoMapper']
+      >;
+    }
+  ) {
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  }
+
+  protected createCacheKey = createCacheKey('billing_portal_session');
+
+  async createBillingPortalSession(
+    billingPortalDto: Dto['CreateBillingPortalDtoMapper']
+  ): Promise<Dto['BillingPortalDtoMapper']> {
+    const billingPortalSession =
+      this.#mapperss.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.#mapperss.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.#mapperss.BillingPortalDtoMapper.serializeEntityToDto(
+      billingPortalSessionDetails.value
+    );
+  }
+
+  async updateBillingPortalSession(
+    billingPortalDto: UpdateBillingPortalDto
+  ): Promise<Dto['BillingPortalDtoMapper']> {
+    const billingPortalSession =
+      this.#mapperss.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.#mapperss.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/checkoutSession.service.ts

@@ -0,0 +1,132 @@
+import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
+import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
+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,
+  CreateCheckoutSessionDto,
+  UpdateCheckoutSessionDto
+} from '@forklaunch/interfaces-billing/types';
+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>
+{
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    protected readonly cache: TtlCache,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected readonly schemaValidator: SchemaValidator,
+    protected readonly mapperss: {
+      CheckoutSessionDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CheckoutSessionDtoMapper'],
+        Entities['CheckoutSessionDtoMapper']
+      >;
+      CreateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateCheckoutSessionDtoMapper'],
+        Entities['CreateCheckoutSessionDtoMapper']
+      >;
+      UpdateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateCheckoutSessionDtoMapper'],
+        Entities['UpdateCheckoutSessionDtoMapper']
+      >;
+    }
+  ) {
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  }
+
+  protected createCacheKey = createCacheKey('checkout_session');
+
+  async createCheckoutSession(
+    checkoutSessionDto: Dto['CreateCheckoutSessionDtoMapper']
+  ): Promise<Dto['CheckoutSessionDtoMapper']> {
+    const checkoutSession =
+      this.#mapperss.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.#mapperss.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.#mapperss.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));
+  }
+}

package/lib/eject/services/index.ts

@@ -0,0 +1,5 @@
+export * from './billingPortal.service';
+export * from './checkoutSession.service';
+export * from './paymentLink.service';
+export * from './plan.service';
+export * from './subscription.service';

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

@@ -0,0 +1,170 @@
+import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
+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,
+  PaymentLinkDto,
+  UpdatePaymentLinkDto
+} from '@forklaunch/interfaces-billing/types';
+import { AnySchemaValidator } from '@forklaunch/validator';
+
+export class BasePaymentLinkService<
+  SchemaValidator extends AnySchemaValidator,
+  CurrencyEnum,
+  Metrics extends MetricsDefinition = MetricsDefinition,
+  Dto extends {
+    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum>;
+    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum>;
+  } = {
+    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum>;
+    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum>;
+  },
+  Entities extends {
+    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+  } = {
+    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum>;
+  }
+> implements PaymentLinkService<CurrencyEnum>
+{
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    protected readonly cache: TtlCache,
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected readonly schemaValidator: SchemaValidator,
+    protected readonly mapperss: {
+      PaymentLinkDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['PaymentLinkDtoMapper'],
+        Entities['PaymentLinkDtoMapper']
+      >;
+      CreatePaymentLinkDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreatePaymentLinkDtoMapper'],
+        Entities['CreatePaymentLinkDtoMapper']
+      >;
+      UpdatePaymentLinkDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdatePaymentLinkDtoMapper'],
+        Entities['UpdatePaymentLinkDtoMapper']
+      >;
+    }
+  ) {
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  }
+
+  protected cacheKeyPrefix = 'payment_link';
+  protected createCacheKey = createCacheKey(this.cacheKeyPrefix);
+
+  async createPaymentLink(
+    paymentLinkDto: Dto['CreatePaymentLinkDtoMapper']
+  ): Promise<Dto['PaymentLinkDtoMapper']> {
+    // TODO: Perform permission checks here
+    const paymentLink =
+      this.#mapperss.CreatePaymentLinkDtoMapper.deserializeDtoToEntity(
+        paymentLinkDto
+      );
+    await this.cache.putRecord({
+      key: this.createCacheKey(paymentLink.id),
+      value: paymentLink,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+
+    return this.#mapperss.PaymentLinkDtoMapper.serializeEntityToDto(
+      paymentLink
+    );
+  }
+
+  async updatePaymentLink(
+    paymentLinkDto: Dto['UpdatePaymentLinkDtoMapper']
+  ): Promise<Dto['PaymentLinkDtoMapper']> {
+    const cacheKey = this.createCacheKey(paymentLinkDto.id);
+    const existingLink =
+      await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(cacheKey);
+    if (!existingLink) {
+      throw new Error('Payment link not found');
+    }
+    const paymentLink =
+      this.#mapperss.UpdatePaymentLinkDtoMapper.deserializeDtoToEntity(
+        paymentLinkDto
+      );
+    const updatedLink = { ...existingLink, ...paymentLink };
+    await this.cache.putRecord({
+      key: cacheKey,
+      value: updatedLink,
+      ttlMilliseconds: this.cache.getTtlMilliseconds()
+    });
+
+    return this.#mapperss.PaymentLinkDtoMapper.serializeEntityToDto(
+      updatedLink
+    );
+  }
+
+  async getPaymentLink({ id }: IdDto): Promise<Dto['PaymentLinkDtoMapper']> {
+    const cacheKey = this.createCacheKey(id);
+    const paymentLink =
+      await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(cacheKey);
+    if (!paymentLink) {
+      throw new Error('Payment link not found');
+    }
+
+    return this.#mapperss.PaymentLinkDtoMapper.serializeEntityToDto(
+      paymentLink.value
+    );
+  }
+
+  async expirePaymentLink({ id }: IdDto): Promise<void> {
+    this.openTelemetryCollector.info('Payment link expired', { id });
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+
+  async handlePaymentSuccess({ id }: IdDto): Promise<void> {
+    this.openTelemetryCollector.info('Payment link success', { id });
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+
+  async handlePaymentFailure({ id }: IdDto): Promise<void> {
+    this.openTelemetryCollector.info('Payment link failure', { id });
+    await this.cache.deleteRecord(this.createCacheKey(id));
+  }
+
+  async listPaymentLinks(
+    idsDto?: IdsDto
+  ): Promise<Dto['PaymentLinkDtoMapper'][]> {
+    const keys =
+      idsDto?.ids.map((id) => this.createCacheKey(id)) ??
+      (await this.cache.listKeys(this.cacheKeyPrefix));
+
+    return await Promise.all(
+      keys.map(async (key) => {
+        const paymentLink =
+          await this.cache.readRecord<Entities['PaymentLinkDtoMapper']>(key);
+        const paymentLinkDto =
+          this.#mapperss.PaymentLinkDtoMapper.serializeEntityToDto(
+            paymentLink.value
+          );
+        return paymentLinkDto;
+      })
+    );
+  }
+}

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

@@ -0,0 +1,132 @@
+import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+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,
+  PlanDto,
+  UpdatePlanDto
+} from '@forklaunch/interfaces-billing/types';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+
+export class BasePlanService<
+  SchemaValidator extends AnySchemaValidator,
+  PlanCadenceEnum,
+  BillingProviderEnum,
+  Metrics extends MetricsDefinition = MetricsDefinition,
+  Dto extends {
+    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
+    CreatePlanDtoMapper: CreatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
+    UpdatePlanDtoMapper: UpdatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
+  } = {
+    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
+    CreatePlanDtoMapper: CreatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
+    UpdatePlanDtoMapper: UpdatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
+  },
+  Entities extends {
+    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
+    CreatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
+    UpdatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
+  } = {
+    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
+    CreatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
+    UpdatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
+  }
+> implements PlanService<PlanCadenceEnum, BillingProviderEnum>
+{
+  #mapperss: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.mapperss>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    private em: EntityManager,
+    private readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    private readonly schemaValidator: SchemaValidator,
+    private readonly mapperss: {
+      PlanDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['PlanDtoMapper'],
+        Entities['PlanDtoMapper']
+      >;
+      CreatePlanDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreatePlanDtoMapper'],
+        Entities['CreatePlanDtoMapper']
+      >;
+      UpdatePlanDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdatePlanDtoMapper'],
+        Entities['UpdatePlanDtoMapper']
+      >;
+    }
+  ) {
+    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
+  }
+
+  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']
+      )
+    );
+  }
+
+  async createPlan(
+    planDto: Dto['CreatePlanDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['PlanDtoMapper']> {
+    const plan =
+      this.#mapperss.CreatePlanDtoMapper.deserializeDtoToEntity(planDto);
+    await (em ?? this.em).transactional(async (innerEm) => {
+      await innerEm.persist(plan);
+    });
+    return this.#mapperss.PlanDtoMapper.serializeEntityToDto(plan);
+  }
+
+  async getPlan(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['PlanDtoMapper']> {
+    const plan = await (em ?? this.em).findOneOrFail('Plan', idDto);
+    return this.#mapperss.PlanDtoMapper.serializeEntityToDto(
+      plan as Entities['PlanDtoMapper']
+    );
+  }
+
+  async updatePlan(
+    planDto: Dto['UpdatePlanDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['PlanDtoMapper']> {
+    const plan =
+      this.#mapperss.UpdatePlanDtoMapper.deserializeDtoToEntity(planDto);
+    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);
+    return updatedPlanDto;
+  }
+
+  async deletePlan(idDto: { id: string }, em?: EntityManager): Promise<void> {
+    await (em ?? this.em).nativeDelete('Plan', idDto);
+  }
+}