@dalmore/api-contracts 1.0.5 → 1.0.6

package/src/common/types/offering-submission.types.ts

@@ -0,0 +1,314 @@
+import { z } from 'zod';
+import { accountIdSchema } from './account.types';
+import { assetIdSchema } from './asset.types';
+import {
+  OfferingType,
+  CoveredPersonsStatus,
+  CoveredPersonsRoleType,
+  AssetType,
+  AccountZod,
+  DurationType,
+  ManagedByType,
+  SubmitIssuerOfferingError,
+  ErrorResponseZod,
+  numberFromStringOrNumber,
+} from './common.types';
+import { coveredPersonIdSchema } from './covered-person.types';
+import { issuerIdSchema, IssuerTypes } from './issuer.types';
+import { offeringIdSchema, offeringRevisionIdSchema } from './offering.types';
+import { StateCode } from './states.types';
+import { CountryCode } from './countries.types';
+
+export const SubmitIssuerOfferingResponse = z.object({
+  valid: z.boolean(),
+  errors: z.array(SubmitIssuerOfferingError),
+  checks: z.object({
+    issuer: ErrorResponseZod,
+    offering: ErrorResponseZod,
+    assets: ErrorResponseZod,
+  }),
+});
+export type SubmitIssuerOfferingResponse = z.infer<
+  typeof SubmitIssuerOfferingResponse
+>;
+export const OfferingsReviewZod = z.object({
+  id: offeringIdSchema,
+  type: z.nativeEnum(OfferingType, {
+    message: 'Type field is required.',
+  }),
+  platform: z
+    .string({ message: 'Platform field is required.' })
+    .min(2, { message: 'Platform ID should have at least 2 characters.' })
+    .max(50, {
+      message: 'Platform ID can’t be longer than 50 characters.',
+    }),
+  enabled: z.boolean({
+    message: 'Enabled field is required.',
+  }),
+  accountId: accountIdSchema,
+  issuerId: issuerIdSchema,
+  managedBy: z
+    .nativeEnum(ManagedByType, {
+      message: 'Please choose a valid type for the offering.',
+    })
+    .nullable(),
+});
+export const OfferingsRevisionReviewZod = z.object({
+  id: offeringRevisionIdSchema, // Assuming this already validates the ID
+  name: z
+    .string({ message: 'Name field is required.' })
+    .min(2, { message: 'Name should have at least 2 characters.' })
+    .max(100, { message: 'Name can’t be longer than 100 characters.' }),
+  description: z
+    .string({ message: 'Description field is required.' })
+    .min(1, { message: 'Description should have at least 1 character.' })
+    .max(1000, {
+      message: 'Description can’t be longer than 1000 characters.',
+    })
+    .optional()
+    .nullable(),
+  tid: z
+    .string({ message: 'Please enter a tid if applicable.' })
+    .min(2, {
+      message: 'Tid should have at least 2 characters.',
+    })
+    .max(50, {
+      message: 'Tid can’t be longer than 50 characters.',
+    })
+    .optional()
+    .nullable(),
+
+  raiseAmount: numberFromStringOrNumber('RaiseAmount')
+    .pipe(
+      z
+        .number()
+        .min(0, { message: 'Raise amount must be at least 0.' })
+        .max(10000000000, {
+          message: 'Raise amount can’t exceed 10 billion.',
+        }),
+    )
+    .nullable()
+    .optional(),
+  targetAmount: numberFromStringOrNumber('TargetAmount').pipe(
+    z
+      .number()
+      .min(0.01, { message: 'Target amount must be at least 0.01.' })
+      .max(10000000000, {
+        message: 'Target amount can’t exceed 10 billion.',
+      }),
+  ),
+
+  minInvestment: numberFromStringOrNumber('MinInvestment')
+    .pipe(
+      z
+        .number()
+        .min(0, { message: 'Minimum investment must be at least 0.' })
+        .max(10000000000, {
+          message: 'Minimum investment can’t exceed 10 billion.',
+        }),
+    )
+    .nullable()
+    .optional(),
+  maxInvestment: numberFromStringOrNumber('MaxInvestment')
+    .pipe(
+      z
+        .number()
+        .min(0, { message: 'Maximum investment must be at least 0.' })
+        .max(10000000000, {
+          message: 'Maximum investment can’t exceed 10 billion.',
+        }),
+    )
+    .nullable()
+    .optional(),
+  contingencyAmount: numberFromStringOrNumber('ContingencyAmount')
+    .pipe(
+      z
+        .number()
+        .min(0, { message: 'Contingency amount must be at least 0.' })
+        .max(10000000000, {
+          message: 'Contingency amount can’t exceed 10 billion.',
+        }),
+    )
+    .nullable()
+    .optional(),
+  startAt: z
+    .date({ message: 'StartAt field is required.' })
+    .nullable()
+    .optional(),
+  endAt: z.date({ message: 'EndAt field is required.' }).nullable().optional(),
+});
+
+export const IssuerReviewZod = z.object({
+  id: issuerIdSchema,
+  accountId: accountIdSchema,
+  legalName: z
+    .string({ message: 'LegalName field is required.' })
+    .min(1, { message: 'Legal name should have at least 1 character.' })
+    .max(100, { message: 'Legal name can’t exceed 100 characters.' }),
+  dba: z
+    .string({
+      message: 'Please provide the Doing Business As (DBA) name if applicable.',
+    })
+    .max(100, { message: 'DBA name can’t exceed 100 characters.' })
+    .nullable()
+    .optional(),
+  ein: z
+    .string({ message: 'EIN field is required.' })
+    .regex(/^\d{9}$/, {
+      message: 'EIN should be exactly 9 digits long.',
+    })
+    .transform((val) => val.replace(/(\d{2})(\d{7})/, '$1-$2'))
+    .nullable()
+    .optional(),
+  type: z.nativeEnum(IssuerTypes, {
+    message: 'Type field is required.',
+    invalid_type_error: 'Selected issuer type is not valid.',
+  }),
+  address: z
+    .string({ message: 'Address field is required.' })
+    .min(2, { message: 'Address should have at least 2 characters.' })
+    .max(150, { message: 'Address can’t exceed 150 characters.' })
+    .nullable()
+    .optional(),
+  address2: z
+    .string({ message: 'Please provide address 2 if applicable.' })
+    .nullable()
+    .optional(),
+  city: z
+    .string({ message: 'City field is required.' })
+    .min(2, { message: 'City should have at least 2 characters.' })
+    .max(50, { message: 'City can’t exceed 50 characters.' })
+    .nullable()
+    .optional(),
+  state: z
+    .nativeEnum(StateCode, {
+      message: 'State field is required.',
+    })
+    .nullable()
+    .optional(),
+  zip: z
+    .string({ message: 'Zip field is required.' })
+    .regex(/^\d{5}$/, {
+      message: 'ZIP code must be a 5-digit number.',
+    })
+    .nullable()
+    .optional(),
+  country: z
+    .nativeEnum(CountryCode, {
+      message: 'Country field is required.',
+    })
+    .nullable()
+    .optional(),
+  ss4LetterFileId: z
+    .string({
+      message: 'Ss4LetterFileId field is required.',
+    })
+    .nullable()
+    .optional(),
+});
+export const CoveredPersonReviewZod = z
+  .object({
+    id: coveredPersonIdSchema,
+    firstName: z
+      .string()
+      .min(2, {
+        message: 'FirstName field is required.',
+      })
+      .max(50, {
+        message: 'First name can’t be longer than 50 characters.',
+      }),
+    lastName: z
+      .string()
+      .min(2, {
+        message: 'LastName field is required.',
+      })
+      .max(50, { message: 'Last name can’t be longer than 50 characters.' })
+      .nullable()
+      .optional(),
+    status: z.nativeEnum(CoveredPersonsStatus, {
+      message: 'Status field is required.',
+    }),
+    issuerId: issuerIdSchema,
+    email: z
+      .string()
+      .email({ message: 'Email field is required.' })
+      .nullable()
+      .optional(),
+    role: z.nativeEnum(CoveredPersonsRoleType, {
+      message: 'Role field is required.',
+    }),
+    ownership: z
+      .number()
+      .min(0, { message: 'Ownership percentage cannot be less than 0%.' })
+      .max(100, { message: 'Ownership percentage cannot exceed 100%.' }),
+    parentId: coveredPersonIdSchema.nullable().optional(),
+    accountId: accountIdSchema,
+  })
+  .superRefine((data, ctx) => {
+    if (data.role !== CoveredPersonsRoleType.ENTITY) {
+      if (!data.email) {
+        ctx.addIssue({
+          path: ['email'],
+          message:
+            'An email address is required when the role type is not ENTITY.',
+          code: 'custom',
+        });
+      }
+    } else {
+      if (data.lastName) {
+        ctx.addIssue({
+          path: ['lastName'],
+          message:
+            'Last name should not be provided when the role type is ENTITY.',
+          code: 'custom',
+        });
+      }
+    }
+  });
+
+const BaseAssetReviewZod = z.object({
+  id: assetIdSchema,
+  name: z
+    .string({ message: 'Name field is required.' })
+    .min(2, { message: 'Name must have at least 2 characters.' })
+    .max(50, { message: 'Name cannot exceed 50 characters.' }),
+  type: z
+    .nativeEnum(AssetType, { message: 'Type field is required.' })
+    .nullable(),
+  pricePerUnit: numberFromStringOrNumber('PricePerUnit').pipe(
+    z
+      .number()
+      .min(0.01, { message: 'Price per unit must be at least 0.01.' })
+      .max(10000000000, {
+        message: 'Price per unit cannot exceed 10 billion.',
+      }),
+  ),
+  totalUnits: numberFromStringOrNumber('TotalUnits').pipe(
+    z
+      .number()
+      .min(0.01, { message: 'Total units must be at least 0.01.' })
+      .max(10000000000, {
+        message: 'Total units cannot exceed 10 billion.',
+      }),
+  ),
+  accountId: accountIdSchema,
+  account: AccountZod.optional().nullable(),
+  offeringId: offeringIdSchema,
+});
+export const StockAssetReviewZod = BaseAssetReviewZod.extend({});
+
+export const BondAssetReviewZod = BaseAssetReviewZod.extend({
+  yield: numberFromStringOrNumber('Yield').pipe(
+    z
+      .number()
+      .min(0.01, { message: 'Yield must be at least 0.01.' })
+      .max(10000000000, { message: 'Yield cannot exceed 10 billion.' }),
+  ),
+  duration: z
+    .number({ message: 'Duration field is required.' })
+    .min(1, { message: 'Duration must be at least 1.' })
+    .max(1000, { message: 'Duration cannot exceed 1000.' }),
+  durationType: z.nativeEnum(DurationType, {
+    message: 'DurationType field is required.',
+  }),
+});

package/src/common/types/offering.types.spec.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { OfferingSettings, OfferingFeeType } from './offering.types';
+
+describe('OfferingSettings Schema', () => {
+  it('should pass with all null or undefined values', () => {
+    const data = {
+      settingsBrokerageFeeValue: null,
+      settingsBrokerageFeeType: null,
+      settingsCardFeeValue: null,
+      settingsCardFeeType: null,
+      settingsDisbursementFeeValue: null,
+      settingsDisbursementFeeType: null,
+      settingsRefundPoolFeeValue: null,
+      settingsRefundPoolFeeType: null,
+      serviceCharges: null,
+      serviceChargesType: null,
+    };
+    expect(() => OfferingSettings.parse(data)).not.toThrow();
+  });
+
+  it('should pass with valid non-null pair values', () => {
+    const data = {
+      settingsBrokerageFeeValue: 50,
+      settingsBrokerageFeeType: OfferingFeeType.PERCENTAGE,
+      settingsCardFeeValue: 25,
+      settingsCardFeeType: OfferingFeeType.PERCENTAGE,
+      settingsDisbursementFeeValue: 30,
+      settingsDisbursementFeeType: OfferingFeeType.PERCENTAGE,
+      settingsRefundPoolFeeValue: 40,
+      settingsRefundPoolFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).not.toThrow();
+  });
+
+  it('should fail if one of a pair is null and the other is not', () => {
+    const data = {
+      settingsBrokerageFeeValue: 10,
+      settingsBrokerageFeeType: null,
+      settingsCardFeeValue: null,
+      settingsCardFeeType: OfferingFeeType.PERCENTAGE,
+      settingsDisbursementFeeValue: 15,
+      settingsDisbursementFeeType: null,
+      settingsRefundPoolFeeValue: null,
+      settingsRefundPoolFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsBrokerageFeeType and settingsBrokerageFeeValue must both be either null or not-null',
+    );
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsCardFeeType and settingsCardFeeValue must both be either null or not-null',
+    );
+  });
+
+  it('should fail if percentage fee values exceed 100', () => {
+    const data = {
+      settingsBrokerageFeeValue: 101,
+      settingsBrokerageFeeType: OfferingFeeType.PERCENTAGE,
+      settingsCardFeeValue: 50,
+      settingsCardFeeType: OfferingFeeType.PERCENTAGE,
+      settingsDisbursementFeeValue: 200,
+      settingsDisbursementFeeType: OfferingFeeType.PERCENTAGE,
+      settingsRefundPoolFeeValue: 150,
+      settingsRefundPoolFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsBrokerageFeeValue must be less than or equal to 100',
+    );
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsDisbursementFeeValue must be less than 100',
+    );
+    expect(() => OfferingSettings.parse(data)).toThrow(
+      'settingsRefundPoolFeeValue must be less than or equal to 100',
+    );
+  });
+
+  it('should fail if required values are missing', () => {
+    const data = {
+      settingsBrokerageFeeValue: undefined,
+      settingsBrokerageFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).toThrow(z.ZodError);
+  });
+
+  it('should fail if invalid types are provided', () => {
+    const data = {
+      settingsBrokerageFeeValue: 'invalid', // should be a number
+      settingsBrokerageFeeType: OfferingFeeType.PERCENTAGE,
+    };
+    expect(() => OfferingSettings.parse(data)).toThrow(z.ZodError);
+  });
+});