@forklaunch/implementation-billing-base 0.1.12 → 0.1.13

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,250 @@
+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,37 @@
+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)
+});

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)
+});