@dalmore/api-contracts 1.0.6 → 1.0.7

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

@@ -1,314 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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);
-  });
-});