@forklaunch/implementation-billing-base 0.1.12 → 0.1.14

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,409 @@
+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({
+  uuidId: false
+});
+const typeboxUpdateBillingPortalSchema = TypeboxUpdateBillingPortalSchema({
+  uuidId: false
+});
+const zodBillingPortalSchema = ZodBillingPortalSchema({ uuidId: false });
+const typeboxBillingPortalSchema = TypeboxBillingPortalSchema({
+  uuidId: false
+});
+const zodCreateCheckoutSessionSchema =
+  ZodCreateCheckoutSessionSchema(DummyEnum);
+const typeboxCreateCheckoutSessionSchema =
+  TypeboxCreateCheckoutSessionSchema(DummyEnum);
+const zodUpdateCheckoutSessionSchema = ZodUpdateCheckoutSessionSchema({
+  uuidId: false
+})(DummyEnum);
+const typeboxUpdateCheckoutSessionSchema = TypeboxUpdateCheckoutSessionSchema({
+  uuidId: false
+})(DummyEnum);
+const zodCheckoutSessionSchema = ZodCheckoutSessionSchema({ uuidId: true })(
+  DummyEnum
+);
+const typeboxCheckoutSessionSchema = TypeboxCheckoutSessionSchema({
+  uuidId: true
+})(DummyEnum);
+const zodCreatePaymentLinkSchema = ZodCreatePaymentLinkSchema(DummyEnum);
+const typeboxCreatePaymentLinkSchema =
+  TypeboxCreatePaymentLinkSchema(DummyEnum);
+const zodUpdatePaymentLinkSchema = ZodUpdatePaymentLinkSchema({
+  uuidId: false
+})(DummyEnum);
+const typeboxUpdatePaymentLinkSchema = TypeboxUpdatePaymentLinkSchema({
+  uuidId: false
+})(DummyEnum);
+const zodPaymentLinkSchema = ZodPaymentLinkSchema({ uuidId: true })(DummyEnum);
+const typeboxPaymentLinkSchema = TypeboxPaymentLinkSchema({
+  uuidId: false
+})(DummyEnum);
+const zodCreatePlanSchema = ZodCreatePlanSchema(DummyEnum, DummyEnum);
+const typeboxCreatePlanSchema = TypeboxCreatePlanSchema(DummyEnum, DummyEnum);
+const zodUpdatePlanSchema = ZodUpdatePlanSchema({ uuidId: false })(
+  DummyEnum,
+  DummyEnum
+);
+const typeboxUpdatePlanSchema = TypeboxUpdatePlanSchema({ uuidId: false })(
+  DummyEnum,
+  DummyEnum
+);
+const zodPlanSchema = ZodPlanSchema({ uuidId: true })(DummyEnum, DummyEnum);
+const typeboxPlanSchema = TypeboxPlanSchema({ uuidId: true })(
+  DummyEnum,
+  DummyEnum
+);
+const zodCreateSubscriptionSchema = ZodCreateSubscriptionSchema(
+  DummyEnum,
+  DummyEnum
+);
+const typeboxCreateSubscriptionSchema = TypeboxCreateSubscriptionSchema(
+  DummyEnum,
+  DummyEnum
+);
+const zodUpdateSubscriptionSchema = ZodUpdateSubscriptionSchema({
+  uuidId: false
+})(DummyEnum, DummyEnum);
+const typeboxUpdateSubscriptionSchema = TypeboxUpdateSubscriptionSchema({
+  uuidId: false
+})(DummyEnum, DummyEnum);
+const zodSubscriptionSchema = ZodSubscriptionSchema({ uuidId: true })(
+  DummyEnum,
+  DummyEnum
+);
+const typeboxSubscriptionSchema = TypeboxSubscriptionSchema({
+  uuidId: true
+})(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/lib/eject/domain/schemas/billingPortal.schema.ts

@@ -0,0 +1,31 @@
+import { date, optional, string, unknown, uuid } from '@{{app_name}}/core';
+
+export const CreateBillingPortalSchema = {
+  customerId: string,
+  uri: string,
+  expiresAt: date
+};
+
+export const UpdateBillingPortalSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  uri: optional(string),
+  expiresAt: optional(date)
+});
+
+export const BillingPortalSchema = ({ uuidId }: { uuidId: boolean }) => ({
+  id: uuidId ? uuid : string,
+  customerId: string,
+  uri: string,
+  expiresAt: date,
+  extraFields: optional(unknown),
+  createdAt: optional(date),
+  updatedAt: optional(date)
+});
+
+export const BaseBillingPortalServiceSchemas = (options: {
+  uuidId: boolean;
+}) => ({
+  CreateBillingPortalSchema,
+  UpdateBillingPortalSchema: UpdateBillingPortalSchema(options),
+  BillingPortalSchema: BillingPortalSchema(options)
+});

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

@@ -0,0 +1,55 @@
+import { LiteralSchema } from '@forklaunch/validator';
+import {
+  array,
+  date,
+  enum_,
+  optional,
+  string,
+  unknown,
+  uuid
+} from '@{{app_name}}/core';
+
+export const CreateCheckoutSessionSchema = <
+  T extends Record<string, LiteralSchema>
+>(
+  PaymentMethodEnum: T
+) => ({
+  customerId: string,
+  paymentMethods: array(enum_(PaymentMethodEnum)),
+  successRedirectUri: string,
+  cancelRedirectUri: string,
+  extraFields: optional(unknown)
+});
+
+export const UpdateCheckoutSessionSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <T extends Record<string, LiteralSchema>>(PaymentMethodEnum: T) => ({
+    id: uuidId ? uuid : string,
+    customerId: optional(string),
+    paymentMethods: optional(array(enum_(PaymentMethodEnum))),
+    successRedirectUri: optional(string),
+    cancelRedirectUri: optional(string),
+    extraFields: optional(unknown)
+  });
+
+export const CheckoutSessionSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <T extends Record<string, LiteralSchema>>(PaymentMethodEnum: T) => ({
+    id: uuidId ? uuid : string,
+    customerId: string,
+    metadata: optional(unknown),
+    paymentMethods: array(enum_(PaymentMethodEnum)),
+    successRedirectUri: string,
+    cancelRedirectUri: string,
+    extraFields: optional(unknown),
+    createdAt: optional(date),
+    updatedAt: optional(date)
+  });
+
+export const BaseCheckoutSessionServiceSchemas = (options: {
+  uuidId: boolean;
+}) => ({
+  CreateCheckoutSessionSchema,
+  UpdateCheckoutSessionSchema: UpdateCheckoutSessionSchema(options),
+  CheckoutSessionSchema: CheckoutSessionSchema(options)
+});

package/lib/eject/domain/schemas/index.ts

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

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

@@ -0,0 +1,60 @@
+import { LiteralSchema } from '@forklaunch/validator';
+import {
+  date,
+  enum_,
+  number,
+  optional,
+  string,
+  unknown,
+  uuid
+} from '@{{app_name}}/core';
+
+export const CreatePaymentLinkSchema = <
+  T extends Record<string, LiteralSchema>
+>(
+  CurrencyEnum: T
+) => ({
+  amount: number,
+  currency: enum_(CurrencyEnum),
+  description: optional(string),
+  metadata: optional(unknown),
+  successRedirectUri: string,
+  cancelRedirectUri: string,
+  extraFields: optional(unknown)
+});
+
+export const UpdatePaymentLinkSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <T extends Record<string, LiteralSchema>>(CurrencyEnum: T) => ({
+    id: uuidId ? uuid : string,
+    amount: optional(number),
+    currency: optional(enum_(CurrencyEnum)),
+    description: optional(string),
+    metadata: optional(unknown),
+    successRedirectUri: optional(string),
+    cancelRedirectUri: optional(string),
+    extraFields: optional(unknown)
+  });
+
+export const PaymentLinkSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <T extends Record<string, LiteralSchema>>(CurrencyEnum: T) => ({
+    id: uuidId ? uuid : string,
+    amount: number,
+    currency: enum_(CurrencyEnum),
+    description: optional(string),
+    metadata: optional(unknown),
+    successRedirectUri: string,
+    cancelRedirectUri: string,
+    extraFields: optional(unknown),
+    createdAt: optional(date),
+    updatedAt: optional(date)
+  });
+
+export const BasePaymentLinkServiceSchemas = (options: {
+  uuidId: boolean;
+}) => ({
+  CreatePaymentLinkSchema,
+  UpdatePaymentLinkSchema: UpdatePaymentLinkSchema(options),
+  PaymentLinkSchema: PaymentLinkSchema(options)
+});

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

@@ -0,0 +1,80 @@
+import { LiteralSchema } from '@forklaunch/validator';
+import {
+  array,
+  boolean,
+  date,
+  enum_,
+  number,
+  optional,
+  string,
+  unknown,
+  uuid
+} from '@{{app_name}}/core';
+
+export const CreatePlanSchema = <
+  T extends Record<string, LiteralSchema>,
+  U extends Record<string, LiteralSchema>
+>(
+  PlanCadenceEnum: T,
+  BillingProviderEnum: U
+) => ({
+  name: string,
+  description: optional(string),
+  price: number,
+  cadence: enum_(PlanCadenceEnum),
+  features: array(string),
+  extraFields: optional(unknown),
+  externalId: string,
+  billingProvider: optional(enum_(BillingProviderEnum)),
+  active: boolean
+});
+
+export const UpdatePlanSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <
+    T extends Record<string, LiteralSchema>,
+    U extends Record<string, LiteralSchema>
+  >(
+    PlanCadenceEnum: T,
+    BillingProviderEnum: U
+  ) => ({
+    id: uuidId ? uuid : string,
+    name: optional(string),
+    description: optional(string),
+    price: optional(number),
+    cadence: optional(enum_(PlanCadenceEnum)),
+    features: optional(array(string)),
+    extraFields: optional(unknown),
+    externalId: optional(string),
+    billingProvider: optional(enum_(BillingProviderEnum)),
+    active: optional(boolean)
+  });
+
+export const PlanSchema =
+  ({ uuidId }: { uuidId: boolean }) =>
+  <
+    T extends Record<string, LiteralSchema>,
+    U extends Record<string, LiteralSchema>
+  >(
+    PlanCadenceEnum: T,
+    BillingProviderEnum: U
+  ) => ({
+    id: uuidId ? uuid : string,
+    name: string,
+    description: optional(string),
+    price: number,
+    cadence: enum_(PlanCadenceEnum),
+    features: optional(array(string)),
+    extraFields: optional(unknown),
+    externalId: string,
+    billingProvider: optional(enum_(BillingProviderEnum)),
+    active: boolean,
+    createdAt: optional(date),
+    updatedAt: optional(date)
+  });
+
+export const BasePlanServiceSchemas = (options: { uuidId: boolean }) => ({
+  CreatePlanSchema,
+  UpdatePlanSchema: UpdatePlanSchema(options),
+  PlanSchema: PlanSchema(options)
+});