@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/common/types/task.types.ts

@@ -0,0 +1,258 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types';
+import {
+  BaseStatus,
+  dateSchema,
+  IPaginationMeta,
+  PortalType,
+  TargetTableConfig,
+  TargetTableEnum,
+} from './common.types';
+import { accountIdSchema } from './account.types';
+import { userIdSchema } from './user.types';
+extendZodWithOpenApi(z);
+
+export enum TaskStatus {
+  PENDING = BaseStatus.PENDING,
+  IN_PROGRESS = BaseStatus.IN_PROGRESS,
+  COMPLETED = BaseStatus.COMPLETED,
+}
+
+/**
+ * WARNING: Any changes to this enum must be reflected in the {@link TaskTypeForEmailMap}
+ */
+export enum TaskType {
+  DOWNLOAD_SIGN = 'DOWNLOAD_SIGN',
+  UPLOAD = 'UPLOAD',
+  TODO = 'TODO',
+  COMPLETE_SUBDOC = 'COMPLETE_SUBDOC',
+  COMPLETE_KYC = 'COMPLETE_KYC',
+  COMPLETE_INVESTOR_PROFILE = 'COMPLETE_INVESTOR_PROFILE',
+  COMPLETE_AIC = 'COMPLETE_AIC',
+  SIGN = 'SIGN',
+  UPDATE_PAYMENT_METHOD = 'UPDATE_PAYMENT_METHOD',
+  SUBMIT_PAYMENT = 'SUBMIT_PAYMENT',
+  RE_UPLOAD_FILE = 'RE_UPLOAD_FILE',
+  INVALID_DOB = 'INVALID_DOB',
+}
+
+export enum TaskPriority {
+  LOW = 'LOW',
+  MEDIUM = 'MEDIUM',
+  HIGH = 'HIGH',
+  URGENT = 'URGENT',
+}
+
+export const taskIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'task';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid task ID format. Must be a valid TypeID with "task" prefix. Example: task_01j5y5ghx8fvc83dmx3pznq7hv',
+  },
+);
+
+const tasksInclude = z.enum(['assignee', 'account', 'createdBy']);
+export const TasksIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          tasksInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${tasksInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${tasksInclude.options.join(',')}`,
+    }),
+});
+export interface TasksIncludeQuery extends z.infer<typeof TasksIncludeQuery> {}
+
+export const TaskZod = IBaseEntity.extend({
+  id: taskIdSchema,
+  title: z.string(),
+  templateName: z.string().nullable(),
+  description: z.string().nullable(),
+  accountId: z.string().nullable(),
+  assigneeId: z.string().nullable(),
+  createdById: z.string(),
+  portalType: z.nativeEnum(PortalType).nullable(),
+  dueDate: z.date().nullable(),
+  taskStatus: z.nativeEnum(TaskStatus),
+  taskType: z.nativeEnum(TaskType).nullable(),
+  priority: z.nativeEnum(TaskPriority).nullable(),
+  isTemplate: z.boolean(),
+  targetTable: z.enum(TargetTableEnum),
+  targetId: z.string(),
+  actionUrl: z.string().nullable(),
+}).refine(
+  (data) => {
+    const { targetTable, targetId } = data;
+    const idPrefix = TargetTableConfig[targetTable].idPrefix;
+    try {
+      const tid = TypeID.fromString(targetId);
+      return tid.getType() === idPrefix;
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      "Invalid target ID format. Must match the corresponding table's ID prefix.",
+    path: ['targetId'],
+  },
+);
+export type TaskZod = z.infer<typeof TaskZod>;
+
+export const IPaginatedTask = z.object({
+  items: z.array(TaskZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedTask = z.infer<typeof IPaginatedTask>;
+
+export const PostTaskBody = z.object({
+  title: z.string().min(2).max(50),
+  description: z.string().max(100).nullable(),
+  accountId: accountIdSchema.nullable(),
+  assigneeId: userIdSchema.nullable(),
+  portalType: z.nativeEnum(PortalType).nullable(),
+  dueDate: dateSchema.nullable(),
+  taskStatus: z.nativeEnum(TaskStatus).optional(),
+  taskType: z.nativeEnum(TaskType).nullable(),
+  priority: z.nativeEnum(TaskPriority).nullable(),
+  isTemplate: z.boolean(),
+  targetTable: z.enum(TargetTableEnum),
+  targetId: z.string().refine(
+    (value) => {
+      try {
+        const tid = TypeID.fromString(value);
+        return Object.values(TargetTableConfig).some(
+          (config) => config.idPrefix === tid.getType(),
+        );
+      } catch {
+        return false;
+      }
+    },
+    {
+      message: `Invalid target ID format. Must match the corresponding table's ID prefix. Valid prefix: ${TargetTableEnum.toString().toLowerCase()}. Example: disbursement_01j6aqmtfyfwy9spjdcnh7yqk7`,
+    },
+  ),
+  actionUrl: z.string().min(1).max(255).nullable().optional(),
+});
+export type PostTaskBody = z.infer<typeof PostTaskBody>;
+
+export const TaskFiltersZod = z.object({
+  search: z.string().max(50).optional(),
+  accountId: accountIdSchema.optional(),
+  assigneeId: userIdSchema.optional(),
+  createdById: userIdSchema.optional(),
+  taskStatus: z.nativeEnum(TaskStatus).optional(),
+  isTemplate: z
+    .string()
+    .optional()
+    .refine((v) => !v || v === 'true' || v === 'false', {
+      message: 'isTemplate must be a boolean string',
+    })
+    .transform((v) => {
+      if (!v) return undefined;
+      return v === 'true';
+    }),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  targetTable: z.enum(TargetTableEnum).optional(),
+  targetId: z
+    .string()
+    .optional()
+    .refine(
+      (value) => {
+        try {
+          if (!value) return true;
+          const tid = TypeID.fromString(value);
+          return Object.values(TargetTableConfig).some(
+            (config) => config.idPrefix === tid.getType(),
+          );
+        } catch {
+          return false;
+        }
+      },
+      {
+        message: `Invalid target ID format. Must match the corresponding table's ID prefix. Valid prefix: ${TargetTableEnum.toString().toLowerCase()}. Example: disbursement_01j6aqmtfyfwy9spjdcnh7yqk7`,
+      },
+    ),
+  priority: z.nativeEnum(TaskPriority).optional(),
+  taskType: z.nativeEnum(TaskType).optional(),
+});
+export type TaskFiltersZod = z.infer<typeof TaskFiltersZod>;
+
+export const InvestorsTaskFiltersZod = TaskFiltersZod.pick({
+  search: true,
+  from: true,
+  to: true,
+  taskType: true,
+  taskStatus: true,
+}).extend({
+  isCompleted: z
+    .string()
+    .optional()
+    .refine((v) => !v || v === 'true' || v === 'false', {
+      message: 'isCompleted should be boolean',
+    })
+    .transform((isCompleted) =>
+      isCompleted === 'true'
+        ? true
+        : isCompleted === 'false'
+          ? false
+          : undefined,
+    ),
+});
+export const IssuersTaskFiltersZod = TaskFiltersZod.omit({
+  accountId: true,
+  assigneeId: true,
+});
+export type IssuersTaskFiltersZod = z.infer<typeof IssuersTaskFiltersZod>;
+
+export const PatchTaskZod = z.object({
+  assigneeId: userIdSchema
+    .optional()
+    .openapi({ example: 'user_01j5y5ghx8fvc83dmx3pznq7hv' }),
+  dueDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  taskStatus: z.nativeEnum(TaskStatus).optional(),
+});
+
+export type PatchTaskZod = z.infer<typeof PatchTaskZod>;
+
+export const PatchInvestorTaskZod = PatchTaskZod.omit({ assigneeId: true });
+export type PatchInvestorTaskZod = z.infer<typeof PatchInvestorTaskZod>;
+
+export const MarkTaskAsDoneZod = z.object({
+  message: z.string(),
+});
+export type MarkTaskAsDoneZod = z.infer<typeof MarkTaskAsDoneZod>;
+
+export const TaskTypeForEmailMap = {
+  [TaskType.DOWNLOAD_SIGN]: 'Download & Sign',
+  [TaskType.UPLOAD]: 'Upload',
+  [TaskType.TODO]: 'To-do',
+  [TaskType.COMPLETE_KYC]: 'Complete KYC',
+  [TaskType.SIGN]: 'Sign',
+  [TaskType.UPDATE_PAYMENT_METHOD]: 'Update Payment Method',
+  [TaskType.COMPLETE_INVESTOR_PROFILE]: 'Complete Investor Profile',
+  [TaskType.COMPLETE_SUBDOC]: 'Complete Subdoc',
+  [TaskType.SUBMIT_PAYMENT]: 'Submit Payment',
+  [TaskType.RE_UPLOAD_FILE]: 'Re-upload File',
+  [TaskType.COMPLETE_AIC]: 'Complete AIC',
+  [TaskType.INVALID_DOB]: 'Update your Date of Birth',
+};

package/src/common/types/trade-adjustment.type.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { tradeIdSchema } from './trade.types';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+import { AdjustmentType } from './common.types';
+
+export const tradeAdjustmentIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'trade_adjustment';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid trade_adjustment ID format. Must be a valid TypeID with "trade_adjustment" prefix.',
+  },
+);
+
+export const TradeAdjustmentZod = IBaseEntity.extend({
+  id: tradeAdjustmentIdSchema,
+  amount: z.number(),
+  tradeId: tradeIdSchema,
+  adjustmentType: z.nativeEnum(AdjustmentType),
+});
+
+export type TradeAdjustmentZod = z.infer<typeof TradeAdjustmentZod>;
+
+export const TradeAdjustmentParams = z.object({
+  id: tradeAdjustmentIdSchema,
+});

package/src/common/types/trade-line-item.type.ts

@@ -0,0 +1,132 @@
+import { z } from 'zod';
+import { assetIdSchema } from './asset.types';
+import { tradeIdSchema } from './trade.types';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+import {
+  AssetType,
+  IPaginationMeta,
+  OfferingType,
+  SignatureStatus,
+} from './common.types';
+import { fileIdSchema } from './file.types';
+import { accountIdSchema } from './account.types';
+import { offeringIdSchema } from './offering.types';
+
+export const tradeLineItemIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'trade_line_item';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid trade_line_item ID format. Must be a valid TypeID with "trade_line_item" prefix.',
+  },
+);
+
+export const TradeLineItemZod = IBaseEntity.extend({
+  id: tradeLineItemIdSchema,
+  quantity: z.number(),
+  pricePerShare: z.number(),
+  total: z.number(),
+  assetId: assetIdSchema,
+  assetName: z.string(),
+  assetType: z.nativeEnum(AssetType).nullable(),
+  tradeId: tradeIdSchema,
+  tid: z.string().nullable(),
+  signaturePlatform: z.string().nullable(),
+  signatureDocumentId: z.string().nullable(),
+  signatureUrl: z.string().nullable(),
+  signatureStatus: z.nativeEnum(SignatureStatus),
+  subdocFileId: z.lazy(() => fileIdSchema).nullable(),
+  lineItemRegulation: z.nativeEnum(OfferingType).nullable(),
+  lineItemCoverArtId: z.lazy(() => fileIdSchema).nullable(),
+});
+
+export type TradeLineItemZod = z.infer<typeof TradeLineItemZod>;
+
+export const TradeLineItemParams = z.object({ id: tradeLineItemIdSchema });
+
+export const PostTradeLineItem = z.object({
+  assetId: assetIdSchema,
+  quantity: z
+    .number()
+    .min(0, 'quantity is less than 0')
+    .max(1000000000, 'quantity is more than 1000000000'),
+});
+export type PostTradeLineItem = z.infer<typeof PostTradeLineItem>;
+
+export const TradeLineItemSignStatusUpdate = z.object({
+  signatureStatus: z.nativeEnum(SignatureStatus),
+});
+export type TradeLineItemSignStatusUpdate = z.infer<
+  typeof TradeLineItemSignStatusUpdate
+>;
+
+export const ReviewTradeLineItemStatus = z.object({
+  tradeLineItems: z.array(tradeLineItemIdSchema).min(1).max(1),
+  signatureStatus: z.nativeEnum(SignatureStatus),
+});
+export type ReviewTradeLineItemStatus = z.infer<
+  typeof ReviewTradeLineItemStatus
+>;
+
+export const TradeLineItemUpdate = z.object({
+  id: tradeLineItemIdSchema.optional(),
+  quantity: z
+    .number()
+    .min(0, 'quantity is less than 0')
+    .max(1000000000, 'quantity is more than 1000000000'),
+});
+export type TradeLineItemUpdate = z.infer<typeof TradeLineItemUpdate>;
+
+export const TradeLineItemResponse = z.object({
+  assetName: z.string().nullable(),
+  total: z.number(),
+  pricePerShare: z.number(),
+  id: tradeLineItemIdSchema,
+  quantity: z.number(),
+});
+export type TradeLineItemResponse = z.infer<typeof TradeLineItemResponse>;
+
+export const TradeLineItemQuery = z.object({
+  reset: z
+    .string()
+    .optional()
+    .default('false')
+    .refine((v) => v === 'true' || v === 'false', {
+      message: 'reset must be a boolean string',
+    })
+    .transform((v) => v === 'true'),
+});
+export type TradeLineItemQuery = z.infer<typeof TradeLineItemQuery>;
+
+export const TradeLineItemFiltersQuery = z.object({
+  accountId: accountIdSchema.optional(),
+  hasSubdoc: z.preprocess(
+    (val) =>
+      val === 'true' || val === '1'
+        ? true
+        : val === 'false' || val === '0'
+          ? false
+          : val,
+    z.boolean().optional(),
+  ),
+  saStatus: z.nativeEnum(SignatureStatus).optional(),
+  offeringId: z.lazy(() => offeringIdSchema).optional(),
+  search: z.string().max(50).optional(),
+});
+export type TradeLineItemFiltersQuery = z.infer<
+  typeof TradeLineItemFiltersQuery
+>;
+
+export const IPaginatedTradeLineItem = z.object({
+  items: z.array(z.lazy(() => TradeLineItemZod)),
+  meta: IPaginationMeta,
+});
+
+export type IPaginatedTradeLineItem = z.infer<typeof IPaginatedTradeLineItem>;