@forklaunch/implementation-billing-base 0.2.0 → 0.2.1

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

@@ -1,8 +1,10 @@
 import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
 import { createCacheKey, TtlCache } from '@forklaunch/core/cache';
 import {
+  evaluateTelemetryOptions,
   MetricsDefinition,
-  OpenTelemetryCollector
+  OpenTelemetryCollector,
+  TelemetryOptions
 } from '@forklaunch/core/http';
 import {
   InternalDtoMapper,
@@ -17,38 +19,47 @@ 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>
 {
   #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,
@@ -68,9 +79,21 @@ export class BasePaymentLinkService<
         Dto['UpdatePaymentLinkDtoMapper'],
         Entities['UpdatePaymentLinkDtoMapper']
       >;
+    },
+    readonly options?: {
+      enableDatabaseBackup?: boolean;
+      telemetry?: TelemetryOptions;
     }
   ) {
     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,44 +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 =
       await this.#mappers.CreatePaymentLinkDtoMapper.deserializeDtoToEntity(
-        paymentLinkDto
+        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.#mappers.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 =
       await this.#mappers.UpdatePaymentLinkDtoMapper.deserializeDtoToEntity(
-        paymentLinkDto
+        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.#mappers.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);
@@ -131,16 +188,38 @@ export class BasePaymentLinkService<
 
   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));
   }
 

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

@@ -1,7 +1,9 @@
 import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
 import {
+  evaluateTelemetryOptions,
   MetricsDefinition,
-  OpenTelemetryCollector
+  OpenTelemetryCollector,
+  TelemetryOptions
 } from '@forklaunch/core/http';
 import {
   InternalDtoMapper,
@@ -48,6 +50,11 @@ export class BasePlanService<
     Entities,
     Dto
   >;
+  private evaluatedTelemetryOptions: {
+    logging?: boolean;
+    metrics?: boolean;
+    tracing?: boolean;
+  };
 
   constructor(
     private em: EntityManager,
@@ -69,15 +76,28 @@ export class BasePlanService<
         Dto['UpdatePlanDtoMapper'],
         Entities['UpdatePlanDtoMapper']
       >;
+    },
+    readonly options?: {
+      telemetry?: TelemetryOptions;
     }
   ) {
     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'][]> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info('Listing plans', idsDto);
+    }
     return Promise.all(
       (
         await (em ?? this.em).findAll('Plan', {
@@ -95,8 +115,13 @@ export class BasePlanService<
     planDto: Dto['CreatePlanDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['PlanDtoMapper']> {
-    const plan =
-      await this.#mappers.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);
     });
@@ -107,6 +132,9 @@ export class BasePlanService<
     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.#mappers.PlanDtoMapper.serializeEntityToDto(
       plan as Entities['PlanDtoMapper']
@@ -117,8 +145,13 @@ export class BasePlanService<
     planDto: Dto['UpdatePlanDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['PlanDtoMapper']> {
-    const plan =
-      await this.#mappers.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);
@@ -129,6 +162,9 @@ export class BasePlanService<
   }
 
   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,7 +1,9 @@
 import { IdDto, InstanceTypeRecord } from '@forklaunch/common';
 import {
+  evaluateTelemetryOptions,
   MetricsDefinition,
-  OpenTelemetryCollector
+  OpenTelemetryCollector,
+  TelemetryOptions
 } from '@forklaunch/core/http';
 import {
   InternalDtoMapper,
@@ -72,6 +74,11 @@ export class BaseSubscriptionService<
     Entities,
     Dto
   >;
+  private evaluatedTelemetryOptions: {
+    logging?: boolean;
+    metrics?: boolean;
+    tracing?: boolean;
+  };
 
   constructor(
     protected em: EntityManager,
@@ -93,6 +100,10 @@ export class BaseSubscriptionService<
         Dto['UpdateSubscriptionDtoMapper'],
         Entities['UpdateSubscriptionDtoMapper']
       >;
+    },
+    readonly options?: {
+      enableDatabaseBackup?: boolean;
+      telemetry?: TelemetryOptions;
     }
   ) {
     this.#mappers = transformIntoInternalDtoMapper<
@@ -101,15 +112,29 @@ export class BaseSubscriptionService<
       Entities,
       Dto
     >(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']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Creating subscription',
+        subscriptionDto
+      );
+    }
     const subscription =
       await this.#mappers.CreateSubscriptionDtoMapper.deserializeDtoToEntity(
-        subscriptionDto
+        subscriptionDto,
+        em ?? this.em
       );
     await (em ?? this.em).transactional(async (innerEm) => {
       await innerEm.persist(subscription);
@@ -125,6 +150,9 @@ 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
@@ -138,6 +166,9 @@ 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',
@@ -153,6 +184,9 @@ 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',
@@ -167,9 +201,16 @@ export class BaseSubscriptionService<
     subscriptionDto: Dto['UpdateSubscriptionDtoMapper'],
     em?: EntityManager
   ): Promise<Dto['SubscriptionDtoMapper']> {
+    if (this.evaluatedTelemetryOptions.logging) {
+      this.openTelemetryCollector.info(
+        'Updating subscription',
+        subscriptionDto
+      );
+    }
     const subscription =
       this.#mappers.UpdateSubscriptionDtoMapper.deserializeDtoToEntity(
-        subscriptionDto
+        subscriptionDto,
+        em ?? this.em
       );
     const updatedSubscription = await (em ?? this.em).upsert(subscription);
     await (em ?? this.em).transactional(async (innerEm) => {
@@ -187,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');
@@ -198,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
         ? {
@@ -220,6 +267,9 @@ export class BaseSubscriptionService<
   }
 
   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');
@@ -231,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');

package/lib/schemas/checkoutSession.schema.d.ts

@@ -14,7 +14,8 @@ export declare const BaseCheckoutSessionServiceSchemas: <
     CreateCheckoutSessionSchema: <
       T extends Record<string, import('@forklaunch/validator').LiteralSchema>
     >(
-      PaymentMethodEnum: T
+      PaymentMethodEnum: T,
+      StatusEnum: T
     ) => {
       customerId: import('@sinclair/typebox').TString;
       paymentMethods: import('@sinclair/typebox').TArray<
@@ -28,14 +29,33 @@ export declare const BaseCheckoutSessionServiceSchemas: <
       >;
       successRedirectUri: import('@sinclair/typebox').TString;
       cancelRedirectUri: import('@sinclair/typebox').TString;
+      expiresAt: import('@sinclair/typebox').TTransform<
+        import('@sinclair/typebox').TUnion<
+          [
+            import('@sinclair/typebox').TString,
+            import('@sinclair/typebox').TNumber,
+            import('@sinclair/typebox').TDate
+          ]
+        >,
+        Date
+      >;
+      status: import('@sinclair/typebox').TUnion<
+        [
+          {
+            [K in keyof T]: import('@sinclair/typebox').TLiteral<T[K]>;
+          }[keyof T]
+        ]
+      >;
       extraFields: import('@sinclair/typebox').TOptional<
         import('@sinclair/typebox').TUnknown
       >;
     };
     UpdateCheckoutSessionSchema: <
-      T extends Record<string, import('@forklaunch/validator').LiteralSchema>
+      T extends Record<string, import('@forklaunch/validator').LiteralSchema>,
+      U extends Record<string, import('@forklaunch/validator').LiteralSchema>
     >(
-      PaymentMethodEnum: T
+      PaymentMethodEnum: T,
+      StatusEnum: U
     ) => {
       id: import('@sinclair/typebox').TString;
       customerId: import('@sinclair/typebox').TOptional<
@@ -58,14 +78,37 @@ export declare const BaseCheckoutSessionServiceSchemas: <
       cancelRedirectUri: import('@sinclair/typebox').TOptional<
         import('@sinclair/typebox').TString
       >;
+      expiresAt: import('@sinclair/typebox').TOptional<
+        import('@sinclair/typebox').TTransform<
+          import('@sinclair/typebox').TUnion<
+            [
+              import('@sinclair/typebox').TString,
+              import('@sinclair/typebox').TNumber,
+              import('@sinclair/typebox').TDate
+            ]
+          >,
+          Date
+        >
+      >;
+      status: import('@sinclair/typebox').TOptional<
+        import('@sinclair/typebox').TUnion<
+          [
+            {
+              [K_1 in keyof U]: import('@sinclair/typebox').TLiteral<U[K_1]>;
+            }[keyof U]
+          ]
+        >
+      >;
       extraFields: import('@sinclair/typebox').TOptional<
         import('@sinclair/typebox').TUnknown
       >;
     };
     CheckoutSessionSchema: <
-      T extends Record<string, import('@forklaunch/validator').LiteralSchema>
+      T extends Record<string, import('@forklaunch/validator').LiteralSchema>,
+      U_1 extends Record<string, import('@forklaunch/validator').LiteralSchema>
     >(
-      PaymentMethodEnum: T
+      PaymentMethodEnum: T,
+      StatusEnum: U_1
     ) => {
       id: import('@sinclair/typebox').TString;
       customerId: import('@sinclair/typebox').TString;
@@ -83,6 +126,23 @@ export declare const BaseCheckoutSessionServiceSchemas: <
       >;
       successRedirectUri: import('@sinclair/typebox').TString;
       cancelRedirectUri: import('@sinclair/typebox').TString;
+      expiresAt: import('@sinclair/typebox').TTransform<
+        import('@sinclair/typebox').TUnion<
+          [
+            import('@sinclair/typebox').TString,
+            import('@sinclair/typebox').TNumber,
+            import('@sinclair/typebox').TDate
+          ]
+        >,
+        Date
+      >;
+      status: import('@sinclair/typebox').TUnion<
+        [
+          {
+            [K_1 in keyof U_1]: import('@sinclair/typebox').TLiteral<U_1[K_1]>;
+          }[keyof U_1]
+        ]
+      >;
       extraFields: import('@sinclair/typebox').TOptional<
         import('@sinclair/typebox').TUnknown
       >;
@@ -116,9 +176,11 @@ export declare const BaseCheckoutSessionServiceSchemas: <
     uuidId: boolean;
   }) => {
     CreateCheckoutSessionSchema: <
-      T extends Record<string, import('@forklaunch/validator').LiteralSchema>
+      T extends Record<string, import('@forklaunch/validator').LiteralSchema>,
+      U_2 extends Record<string, import('@forklaunch/validator').LiteralSchema>
     >(
-      PaymentMethodEnum: T
+      PaymentMethodEnum: T,
+      StatusEnum: U_2
     ) => {
       customerId: import('zod').ZodString;
       paymentMethods: import('zod').ZodArray<
@@ -129,12 +191,18 @@ export declare const BaseCheckoutSessionServiceSchemas: <
       >;
       successRedirectUri: import('zod').ZodString;
       cancelRedirectUri: import('zod').ZodString;
+      expiresAt: import('zod').ZodEffects<import('zod').ZodDate, Date, unknown>;
+      status: import('zod').ZodUnion<
+        [{ [K_1 in keyof U_2]: import('zod').ZodLiteral<U_2[K_1]> }[keyof U_2]]
+      >;
       extraFields: import('zod').ZodOptional<import('zod').ZodUnknown>;
     };
     UpdateCheckoutSessionSchema: <
-      T extends Record<string, import('@forklaunch/validator').LiteralSchema>
+      T extends Record<string, import('@forklaunch/validator').LiteralSchema>,
+      U_3 extends Record<string, import('@forklaunch/validator').LiteralSchema>
     >(
-      PaymentMethodEnum: T
+      PaymentMethodEnum: T,
+      StatusEnum: U_3
     ) => {
       id: import('zod').ZodString;
       customerId: import('zod').ZodOptional<import('zod').ZodString>;
@@ -148,12 +216,26 @@ export declare const BaseCheckoutSessionServiceSchemas: <
       >;
       successRedirectUri: import('zod').ZodOptional<import('zod').ZodString>;
       cancelRedirectUri: import('zod').ZodOptional<import('zod').ZodString>;
+      expiresAt: import('zod').ZodOptional<
+        import('zod').ZodEffects<import('zod').ZodDate, Date, unknown>
+      >;
+      status: import('zod').ZodOptional<
+        import('zod').ZodUnion<
+          [
+            {
+              [K_1 in keyof U_3]: import('zod').ZodLiteral<U_3[K_1]>;
+            }[keyof U_3]
+          ]
+        >
+      >;
       extraFields: import('zod').ZodOptional<import('zod').ZodUnknown>;
     };
     CheckoutSessionSchema: <
-      T extends Record<string, import('@forklaunch/validator').LiteralSchema>
+      T extends Record<string, import('@forklaunch/validator').LiteralSchema>,
+      U_4 extends Record<string, import('@forklaunch/validator').LiteralSchema>
     >(
-      PaymentMethodEnum: T
+      PaymentMethodEnum: T,
+      StatusEnum: U_4
     ) => {
       id: import('zod').ZodString;
       customerId: import('zod').ZodString;
@@ -166,6 +248,10 @@ export declare const BaseCheckoutSessionServiceSchemas: <
       >;
       successRedirectUri: import('zod').ZodString;
       cancelRedirectUri: import('zod').ZodString;
+      expiresAt: import('zod').ZodEffects<import('zod').ZodDate, Date, unknown>;
+      status: import('zod').ZodUnion<
+        [{ [K_1 in keyof U_4]: import('zod').ZodLiteral<U_4[K_1]> }[keyof U_4]]
+      >;
       extraFields: import('zod').ZodOptional<import('zod').ZodUnknown>;
       createdAt: import('zod').ZodOptional<
         import('zod').ZodEffects<import('zod').ZodDate, Date, unknown>

package/lib/schemas/checkoutSession.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkoutSession.schema.d.ts","sourceRoot":"","sources":["../../schemas/checkoutSession.schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7C,CAAC"}
+{"version":3,"file":"checkoutSession.schema.d.ts","sourceRoot":"","sources":["../../schemas/checkoutSession.schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7C,CAAC"}