@dalmore/api-contracts 1.0.6 → 1.0.7

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

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

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

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

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

@@ -1,97 +0,0 @@
-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> {}