@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/common/types/batch-jobs.types.ts

@@ -0,0 +1,151 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { dateSchema, IPaginationMeta, UserRole } from './common.types';
+import { userIdSchema } from './user.types';
+import { accountIdSchema } from './account.types';
+import { IBaseEntity } from './entity.types';
+import { JobsOptions } from 'bullmq';
+
+extendZodWithOpenApi(z);
+
+export enum JobTaskType {
+  BULK_TRADE_APPROVAL = 'BULK_TRADE_APPROVAL',
+  SINGLE_TRADE_APPROVAL = 'SINGLE_TRADE_APPROVAL',
+  BULK_TRADE_REJECTION = 'BULK_TRADE_REJECTION',
+  SINGLE_TRADE_REJECTION = 'SINGLE_TRADE_REJECTION',
+  BULK_COMPLIANCE_REVIEW = 'BULK_COMPLIANCE_REVIEW',
+  BULK_EXCHANGE_IMPORT = 'BULK_EXCHANGE_IMPORT',
+  VALIDATE_PLACED_TRADES = 'VALIDATE_PLACED_TRADES',
+  IMPORT_FUNDING_CHECK = 'IMPORT_FUNDING_CHECK',
+  REG_D_TRADE_PROCESSING = 'REG_D_TRADE_PROCESSING',
+  BULK_FILE_REPROCESSING = 'BULK_FILE_REPROCESSING',
+}
+
+export enum BatchJobStatus {
+  PENDING = 'PENDING',
+  IN_PROGRESS = 'IN_PROGRESS',
+  COMPLETED = 'COMPLETED',
+  FAILED = 'FAILED',
+  CANCELLED = 'CANCELLED',
+  KILLED = 'KILLED',
+}
+
+export const batchJobIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'batch_job';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid batch job ID format. Must be a valid TypeID with "batch_job" prefix.',
+  },
+);
+
+export const CreateBatchJobZod = z.object({
+  jobTaskType: z.nativeEnum(JobTaskType),
+  totalTasks: z.number().int(),
+  bullFlowId: z.string(),
+  userId: userIdSchema,
+  accountId: accountIdSchema,
+});
+export type CreateBatchJobZod = z.infer<typeof CreateBatchJobZod>;
+
+export const BatchJobZod = IBaseEntity.extend({
+  id: batchJobIdSchema,
+  jobTaskType: z.nativeEnum(JobTaskType),
+  totalTasks: z.number().int(),
+  bullFlowId: z.string(),
+  userId: userIdSchema,
+  accountId: accountIdSchema,
+  status: z.nativeEnum(BatchJobStatus),
+  tasksPending: z.number().int(),
+  tasksProcessing: z.number().int(),
+  tasksCompleted: z.number().int(),
+  tasksFailed: z.number().int(),
+});
+export type BatchJobZod = z.infer<typeof BatchJobZod>;
+export const IPaginatedBatchJob = z.object({
+  items: z.array(BatchJobZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedBatchJob = z.infer<typeof IPaginatedBatchJob>;
+
+export const BatchJobFiltersZod = z.object({
+  search: z.string().optional(),
+  jobTaskType: z.nativeEnum(JobTaskType).optional(),
+  status: z.nativeEnum(BatchJobStatus).optional(),
+  accountId: accountIdSchema.optional(),
+  userId: userIdSchema.optional(),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type BatchJobFiltersZod = z.infer<typeof BatchJobFiltersZod>;
+const batchJobsInclude = z.enum(['user', 'account', 'jobItems']);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(AccountsIncludeQuery),
+ */
+export const BatchJobsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          batchJobsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${batchJobsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${batchJobsInclude.options.join(',')}`,
+    }),
+});
+export interface BatchJobsIncludeQuery
+  extends z.infer<typeof BatchJobsIncludeQuery> {}
+
+export interface ChildJobConfig {
+  name: string;
+  queueName: string;
+  data: ChildJobData;
+  opts: JobsOptions;
+}
+
+export const ChildJobData = z.object({
+  batchJobId: z.string(),
+  targetId: z.string(),
+  userId: z.string(),
+  userAccountId: z.string(),
+  userFirstName: z.string().optional(),
+  userLastName: z.string().optional(),
+  userRoleId: z.string().optional(),
+  userRole: z.nativeEnum(UserRole).optional(),
+});
+export type ChildJobData = z.infer<typeof ChildJobData>;
+
+export const BatchJobData = z.object({
+  taskType: z.nativeEnum(JobTaskType),
+  props: z.record(z.string(), z.any()),
+});
+export type BatchJobData = z.infer<typeof BatchJobData>;
+
+export const BatchJobResult = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  jobId: z.string().nullable().optional(),
+});
+export type BatchJobResult = z.infer<typeof BatchJobResult>;
+
+export interface BatchJobConfig {
+  data: BatchJobData;
+  childConfigs: (childData: ChildJobData) => ChildJobConfig[];
+  opts: JobsOptions;
+}

package/src/common/types/bonus-tier.types.ts

@@ -0,0 +1,147 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { assetIdSchema, IAsset } from './asset.types';
+import { AccountZod } from './common.types';
+import { accountIdSchema } from './account.types';
+
+extendZodWithOpenApi(z);
+
+export const bonusTierIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'bonus_tier';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid bonus tier ID format. Must be a valid TypeID with "bonus_tier" prefix. Example: bonus_tier_01j5y5ghx5fg68d663j1fvy2x7`,
+  },
+);
+
+export enum BonusType {
+  PERCENTAGE = 'PERCENTAGE',
+  FIXED = 'FIXED',
+}
+
+export const bonusTiersInclude = z.enum(['account', 'asset']);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(BonusTiersIncludeQuery),
+ */
+export const BonusTiersIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          bonusTiersInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${bonusTiersInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${bonusTiersInclude.options.join(',')}`,
+    }),
+});
+
+export const IBonusTier = IBaseEntity.extend({
+  assetId: z.lazy(() => assetIdSchema),
+  asset: z.lazy(() => IAsset),
+  accountId: z.lazy(() => accountIdSchema),
+  account: z.lazy(() => AccountZod),
+  order: z.number(),
+  type: z.nativeEnum(BonusType),
+  value: z.number(),
+  startValue: z.number().nullable(),
+  endValue: z.number().nullable(),
+  startAmount: z.number().nullable(),
+  endAmount: z.number().nullable(),
+});
+
+export const IBonusTierList = z.array(IBonusTier);
+export type IBonusTierList = z.infer<typeof IBonusTierList>;
+
+export const EstimateBonusTierCalculationZod = z
+  .object({
+    assetId: assetIdSchema
+      .optional()
+      .openapi({ example: 'asset_00041061050r3gg28a1c60t3gf' }),
+    bonusTierId: bonusTierIdSchema.optional().openapi({
+      example: 'bonus_tier_01j5y5ghx5fg68d663j1fvy2x7',
+    }),
+    type: z.nativeEnum(BonusType).openapi({ example: BonusType.PERCENTAGE }),
+    value: z.number().positive().int().openapi({ example: 50 }),
+    startAmount: z.number().positive().openapi({ example: 100 }),
+    endAmount: z.number().positive().openapi({ example: 200 }),
+    pricePerShare: z.number().positive().openapi({ example: 100 }),
+  })
+  .refine(
+    (data) => {
+      if (data.type === BonusType.PERCENTAGE) {
+        return data.value <= 100;
+      }
+      return true;
+    },
+    {
+      message: 'Value must be less than or equal to 100 for percentage type',
+    },
+  );
+export type EstimateBonusTierCalculationZod = z.infer<
+  typeof EstimateBonusTierCalculationZod
+>;
+
+export const EstimateBonusTierCalculationResponseZod = z.object({
+  bonusTierId: bonusTierIdSchema
+    .nullable()
+    .openapi({ example: 'bonus_tier_01j5y5ghx5fg68d663j1fvy2x7' }),
+  assetId: assetIdSchema
+    .nullable()
+    .openapi({ example: 'asset_00041061050r3gg28a1c60t3gf' }),
+  type: z
+    .nativeEnum(BonusType)
+    .nullable()
+    .openapi({ example: BonusType.PERCENTAGE }),
+  startValue: z.number().openapi({ example: 100 }),
+  endValue: z.number().openapi({ example: 200 }),
+});
+
+export type EstimateBonusTierCalculationResponseZod = z.infer<
+  typeof EstimateBonusTierCalculationResponseZod
+>;
+export type IBonusTier = z.infer<typeof IBonusTier>;
+export const BonusTierListZod = z
+  .array(
+    z.object({
+      type: z.nativeEnum(BonusType).openapi({ example: BonusType.PERCENTAGE }),
+      value: z.number().positive().int().max(1000000).openapi({ example: 50 }),
+      startAmount: z.number().max(999999999).openapi({ example: 100 }),
+      endAmount: z.number().max(999999999).openapi({ example: 200 }),
+    }),
+  )
+  .min(1, { message: 'At least one bonus tier is required' });
+export type BonusTierListZod = z.infer<typeof BonusTierListZod>;
+
+export const PostBonusTierZod = z.object({
+  assetId: assetIdSchema.openapi({
+    example: 'asset_00041061050r3gg28a1c60t3gf',
+  }),
+  bonusTiers: BonusTierListZod,
+});
+
+export type PostBonusTierZod = z.infer<typeof PostBonusTierZod>;
+
+export const CompliancePostBonusTierZod = PostBonusTierZod.extend({
+  accountId: accountIdSchema,
+});
+
+export type CompliancePostBonusTierZod = z.infer<
+  typeof CompliancePostBonusTierZod
+>;

package/src/common/types/cart.types.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TradeStatus } from './common.types';
+import { investorAccountIdSchema } from './investor-account.types';
+import { paymentMethodIdSchema } from './payment-methods.types';
+
+extendZodWithOpenApi(z);
+
+export const PlaceTradeResponse = z.object({
+  tradeStatus: z.nativeEnum(TradeStatus).optional(),
+});
+export const PlaceTradeBody = z.object({});
+
+export const PatchCartBody = z.object({
+  investorAccountId: investorAccountIdSchema.optional(),
+  paymentMethodId: paymentMethodIdSchema.optional(),
+});
+export type PatchCartBody = z.infer<typeof PatchCartBody>;

package/src/common/types/checklist-items.types.ts

@@ -0,0 +1,70 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { dateSchema, IPaginationMeta } from './common.types';
+
+export const checklistItemsIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'check_list_item';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid check_list_item ID format. Must be a valid TypeID with "check_list_item" prefix.',
+  },
+);
+
+export const PostChecklistItemSchema = z.object({
+  checkListId: z.string(),
+  name: z.string(),
+  title: z.string().nullish(),
+  description: z.string().nullish(),
+  target: z.string().nullish(),
+});
+export type PostChecklistItem = z.infer<typeof PostChecklistItemSchema>;
+
+export const ResponseChecklistItemSchema = z.object({
+  name: z.string().nullish(),
+  title: z.string().nullish(),
+  description: z.string().nullish(),
+  target: z.string().nullish(),
+  sortOrder: z.number().nullish(),
+  id: checklistItemsIdSchema,
+});
+export type ResponseChecklistItem = z.infer<typeof ResponseChecklistItemSchema>;
+
+export const ArrayResponseChecklistItemSchema = z.array(
+  ResponseChecklistItemSchema,
+);
+
+export const PatchChecklistItemSchema = z.object({
+  name: z.string(),
+  title: z.string().nullish(),
+  description: z.string().nullish(),
+  target: z.string().nullish(),
+  sortOrder: z.number().nullish(),
+  id: checklistItemsIdSchema.optional(),
+});
+export type PatchChecklistItem = z.infer<typeof PostChecklistItemSchema>;
+
+export const ParamsChecklistItemSchema = z.object({
+  id: checklistItemsIdSchema,
+});
+export type ParamsChecklistItem = z.infer<typeof ParamsChecklistItemSchema>;
+
+export const ChecklistItemsFiltersZodSchema = z.object({
+  name: z.string().optional(),
+  title: z.string().optional(),
+  id: z.string().optional(),
+  checkListId: z.string().optional(),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+
+export const IPaginatedChecklistItemSchema = z.object({
+  items: z.array(ResponseChecklistItemSchema),
+  meta: IPaginationMeta,
+});

package/src/common/types/checklist.types.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { dateSchema, IPaginationMeta } from './common.types';
+import { TypeID } from 'typeid-js';
+
+export const checklistIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'check_list';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid check_list ID format. Must be a valid TypeID with "check_list" prefix.',
+  },
+);
+
+export const ChecklistFiltersZodSchema = z.object({
+  name: z.string().optional(),
+  type: z.string().optional(),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type ChecklistFiltersZod = z.infer<typeof ChecklistFiltersZodSchema>;
+
+export const ChecklistParamsZodSchema = z.object({
+  id: checklistIdSchema,
+});
+export type ChecklistParams = z.infer<typeof ChecklistParamsZodSchema>;
+
+export const ResponseChecklistZodSchema = z.object({
+  name: z.string().nullable(),
+  type: z.string().nullable(),
+  id: checklistIdSchema,
+});
+export type ResponseChecklist = z.infer<typeof ResponseChecklistZodSchema>;
+
+const ChecklistSchema = z.object({
+  name: z.string().nullish(),
+  type: z.string().nullish(),
+  id: checklistIdSchema,
+});
+
+export const IPaginatedChecklistSchema = z.object({
+  items: z.array(ChecklistSchema),
+  meta: IPaginationMeta,
+});
+export type IPaginatedChecklist = z.infer<typeof IPaginatedChecklistSchema>;
+
+export const PostChecklistSchema = z.object({
+  name: z.string().nullish(),
+  type: z.string().nullish(),
+});
+export type PostChecklist = z.infer<typeof PostChecklistSchema>;
+
+export const PatchChecklistSchema = z.object({
+  name: z.string().nullish(),
+  type: z.string().nullish(),
+  id: checklistIdSchema.optional(),
+});
+export type PatchChecklist = z.infer<typeof PatchChecklistSchema>;
+
+const ChecklistInclude = z.enum([
+  'items',
+  'reviewedBy',
+  'offering',
+  'trades',
+  'account',
+  'items',
+]);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(),
+ */
+export const ChecklistIncludeQuerySchema = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          ChecklistInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${ChecklistInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${ChecklistInclude.options.join(',')}`,
+    }),
+});
+export interface ChecklistIncludeQuery
+  extends z.infer<typeof ChecklistIncludeQuerySchema> {}