@dalmore/api-contracts 1.0.5 → 1.0.6

package/src/common/types/account.types.ts

@@ -0,0 +1,296 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import {
+  AccountZod,
+  dateSchema,
+  IPaginationMeta,
+  IssuerOnboardingSetupType,
+  ManagedByType,
+  Platform,
+  SortBy,
+  SortOrder,
+  AccountStatus,
+} from './common.types';
+import { notionPageIdSchema } from './notion-page.types';
+
+extendZodWithOpenApi(z);
+
+export const accountIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'account';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid account ID format. Must be a valid TypeID with "account" prefix.',
+  },
+);
+
+export const UpdateAccountZod = z.object({
+  name: z.string().min(1).max(100),
+  status: z.nativeEnum(AccountStatus).optional(),
+  platform: z
+    .nativeEnum(Platform)
+    .optional()
+    .openapi({ example: Platform.INTEGRATION }),
+  managedBy: z
+    .nativeEnum(ManagedByType)
+    .optional()
+    .openapi({ example: ManagedByType.DALMORE }),
+  approversCount: z.number().min(1).max(5).optional(),
+});
+export type UpdateAccountZod = z.infer<typeof UpdateAccountZod>;
+
+export const CreateAccountZod = z.object({
+  name: z.string().min(1).max(100).openapi({ example: 'Name' }),
+  platform: z
+    .nativeEnum(Platform)
+    .optional()
+    .openapi({ example: Platform.INTEGRATION }),
+  managedBy: z
+    .nativeEnum(ManagedByType)
+    .optional()
+    .openapi({ example: ManagedByType.DALMORE }),
+  approversCount: z.number().min(1).max(5).optional().openapi({ example: 2 }),
+  hubspotCompany: z
+    .string()
+    .url()
+    .max(2048)
+    .nullable()
+    .optional()
+    .openapi({ example: 'https://www.google.com' }),
+});
+export type CreateAccountZod = z.infer<typeof CreateAccountZod>;
+
+export const IPaginatedAccount = z.object({
+  items: z.array(AccountZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedAccount = z.infer<typeof IPaginatedAccount>;
+
+export const AccountFiltersZod = z.object({
+  search: z.string().max(50).optional(),
+  status: z.nativeEnum(AccountStatus).optional(),
+  platform: z
+    .nativeEnum(Platform)
+    .optional()
+    .openapi({ example: Platform.INTEGRATION }),
+  managedBy: z
+    .nativeEnum(ManagedByType)
+    .optional()
+    .openapi({ example: ManagedByType.DALMORE }),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+
+const accountsInclude = z.enum([
+  'accountManager',
+  'accountIntegrations',
+  'apiKeys',
+  'assets',
+  'dataRooms',
+  'individuals',
+  'investorAccounts',
+  'invites',
+  'issuers',
+  'legalEntities',
+  'offerings',
+  'sites',
+  'trades',
+  'users',
+]);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(AccountsIncludeQuery),
+ */
+export const AccountsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          accountsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${accountsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${accountsInclude.options.join(',')}`,
+    }),
+});
+export interface AccountsIncludeQuery
+  extends z.infer<typeof AccountsIncludeQuery> {}
+
+export const PatchAccountZod = z.object({
+  name: z.string().min(1).max(100),
+  approversCount: z.number().min(1).max(5).optional(),
+  managedBy: z.nativeEnum(ManagedByType).optional(),
+  platform: z.nativeEnum(Platform).optional(),
+  integrationGuideId: notionPageIdSchema.nullable().optional(),
+  productPrimaries: z.boolean().optional(),
+  productSecondaries: z.boolean().optional(),
+  featureDisbursements: z.boolean().optional(),
+});
+export type PatchAccountZod = z.infer<typeof PatchAccountZod>;
+
+export const CompliancePatchAccountZod = PatchAccountZod.extend({
+  hubspotCompany: z
+    .string()
+    .url()
+    .max(2048)
+    .nullable()
+    .optional()
+    .openapi({ example: 'https://www.google.com' }),
+});
+export type CompliancePatchAccountZod = z.infer<
+  typeof CompliancePatchAccountZod
+>;
+
+export const PostAccountResponse = z.object({
+  id: z.string(),
+});
+export type PostAccountResponse = z.infer<typeof PostAccountResponse>;
+
+export const GetAccountIssuersZod = z.object({
+  name: z.string().optional(),
+  accountId: accountIdSchema.optional(),
+});
+export type GetAccountIssuersZod = z.infer<typeof GetAccountIssuersZod>;
+
+export const UpdateAccountIssuersStatusZod = z.object({
+  status: z.nativeEnum(AccountStatus),
+});
+export type UpdateAccountIssuersStatusZod = z.infer<
+  typeof UpdateAccountIssuersStatusZod
+>;
+
+export const UpdateAccountStatusReponse = z.object({
+  id: accountIdSchema,
+  status: z.nativeEnum(AccountStatus),
+});
+export type UpdateAccountStatusReponse = z.infer<
+  typeof UpdateAccountStatusReponse
+>;
+
+export const AccountsSummaryFilterZod = z.object({
+  search: z.string().trim().max(50).optional(),
+  status: z.nativeEnum(AccountStatus).optional(),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  accountManagerIds: z
+    .string()
+    .optional()
+    .transform((val) => {
+      if (!val || typeof val !== 'string') return undefined;
+
+      const ids = val
+        .split(',')
+        .map((id: string) => id.trim())
+        .filter((id: string) => id.length > 0);
+
+      // Remove duplicates using Set
+      const uniqueIds = [...new Set(ids)];
+
+      return uniqueIds.length > 0 ? uniqueIds : undefined;
+    })
+    .pipe(
+      z
+        .array(
+          z.string().refine(
+            (value) => {
+              try {
+                const tid = TypeID.fromString(value);
+                return tid.getType() === 'account_manager';
+              } catch {
+                return false;
+              }
+            },
+            {
+              message: `Invalid account manager ID format. Must be a valid TypeID with "account_manager" prefix. Example: account_manager_01j5y5ghx5fg68d663j1fvy2x7`,
+            },
+          ),
+        )
+        .optional(),
+    ),
+});
+export type AccountsSummaryFilterZod = z.infer<typeof AccountsSummaryFilterZod>;
+
+export const AccountSortZod = z.object({
+  sort: z.enum([SortBy.NAME, SortBy.CREATED_AT, SortBy.UPDATED_AT]).optional(),
+  dir: z.nativeEnum(SortOrder).optional(),
+});
+export type AccountSortZod = z.infer<typeof AccountSortZod>;
+
+export const AccountsSummaryZod = z.object({
+  accountId: accountIdSchema,
+  accountName: z.string(),
+  issuers: z.number().int(),
+  offerings: z.number().int(),
+  assets: z.number().int(),
+  users: z.number().int(),
+  trades: z.number().int(),
+  accountManagerName: z.string(),
+  createdOn: z.string(),
+  status: z.string(),
+});
+export type AccountsSummaryZod = z.infer<typeof AccountsSummaryZod>;
+
+export const IPaginatedAccountsSummaryResponse = z.object({
+  items: z.array(AccountsSummaryZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedAccountsSummaryResponse = z.infer<
+  typeof IPaginatedAccountsSummaryResponse
+>;
+export const PatchIssuerOnboardingStep = z.object({
+  step: z.nativeEnum(IssuerOnboardingSetupType),
+});
+export type PatchIssuerOnboardingStep = z.infer<
+  typeof PatchIssuerOnboardingStep
+>;
+
+export const IssuerOnboardingStepZod = z.object({
+  offeringSetup: z.boolean().default(false),
+  investorPortalSetup: z.boolean().default(false),
+  paymentMethodSetup: z.boolean().default(false),
+  accountContactsSetup: z.boolean().default(false),
+});
+export type IssuerOnboardingStepZod = z.infer<typeof IssuerOnboardingStepZod>;
+
+export const OnboardingAccountSummaryZod = z.object({
+  accountId: accountIdSchema,
+  accountName: z.string(),
+  siteId: z.string().nullable(),
+  offeringId: z.string().nullable(),
+  investorPortalSetup: z.boolean(),
+  offeringSetup: z.boolean(),
+  paymentMethodSetup: z.boolean(),
+  accountContactsSetup: z.boolean(),
+});
+export type OnboardingAccountSummaryZod = z.infer<
+  typeof OnboardingAccountSummaryZod
+>;
+
+export const IPaginatedOnboardingAccountSummaryResponse = z.object({
+  items: z.array(OnboardingAccountSummaryZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedOnboardingAccountSummaryResponse = z.infer<
+  typeof IPaginatedOnboardingAccountSummaryResponse
+>;
+
+export const OnboardingAccountSummaryFilterZod = z.object({
+  status: z.nativeEnum(AccountStatus).optional(),
+});
+export type OnboardingAccountSummaryFilterZod = z.infer<
+  typeof OnboardingAccountSummaryFilterZod
+>;

package/src/common/types/activity.types.ts

@@ -0,0 +1,274 @@
+import { z } from 'zod';
+import {
+  BaseAction,
+  BaseStatus,
+  IPaginationMeta,
+  PortalType,
+  TargetTableConfig,
+  TargetTableEnum,
+} from './common.types';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+
+/**
+ * WARNING!!!
+ * ANY CHANGES TO:
+ * - ActivityTypeCategory
+ * - ActivityTypeResource
+ * - ActivityTypeAction
+ * Will require a migration to add the new combinations to the database. See activity-type.entity.ts
+ * Also, previous migrations will have to be updated to prevent the new combination from being seeded before the new migration introduces it.
+ * see: SeedActivityActionTable1733789494520
+ * This is required only for backwards compatibility when developing locally and e2e tests.
+ */
+export enum ActivityTypeCategory {
+  CLIENT = PortalType.CLIENT,
+  INVESTOR = PortalType.INVESTOR,
+  COMPLIANCE = PortalType.COMPLIANCE,
+  ISSUER = PortalType.ISSUER,
+}
+
+export const CategoryMap: { [key: string]: ActivityTypeCategory } = {
+  compliance: ActivityTypeCategory.COMPLIANCE,
+  issuers: ActivityTypeCategory.ISSUER,
+  clients: ActivityTypeCategory.CLIENT,
+  investors: ActivityTypeCategory.INVESTOR,
+};
+
+export enum ActivityTypeResource {
+  KYCS = 'KYCS',
+  KYBS = 'KYBS',
+  INDIVIDUALS = 'INDIVIDUALS',
+  LEGAL_ENTITIES = 'LEGAL_ENTITIES',
+  INVESTOR_ACCOUNTS = 'INVESTOR_ACCOUNTS',
+  TRADES = 'TRADES',
+  OFFERINGS = 'OFFERINGS',
+  ISSUERS = 'ISSUERS',
+  COVERED_PERSONS = 'COVERED_PERSONS',
+  PAYMENT_METHODS = 'PAYMENT_METHODS',
+  NOTES = 'NOTES',
+  USERS = 'USERS',
+  ACCOUNTS = 'ACCOUNTS',
+  FILES = 'FILES',
+  PAGES = 'PAGES',
+  AMLS = 'AMLS',
+  DISBURSEMENTS = 'DISBURSEMENTS',
+  DISBURSEMENT_REVIEWS = 'DISBURSEMENT_REVIEWS',
+  TRADE_LINE_ITEMS = 'TRADE_LINE_ITEMS',
+  TRANSACTIONS = 'TRANSACTIONS',
+  AICS = 'AICS',
+  SITES = 'SITES',
+  THEMES = 'THEMES',
+  THEME_SETTINGS = 'THEME_SETTINGS',
+}
+
+export const ResourceMap: { [key: string]: ActivityTypeResource } = {
+  trades: ActivityTypeResource.TRADES,
+  'trade-line-items': ActivityTypeResource.TRADE_LINE_ITEMS,
+  transactions: ActivityTypeResource.TRANSACTIONS,
+  users: ActivityTypeResource.USERS,
+  offerings: ActivityTypeResource.OFFERINGS,
+  'investor-accounts': ActivityTypeResource.INVESTOR_ACCOUNTS,
+  individuals: ActivityTypeResource.INDIVIDUALS,
+  'payment-methods': ActivityTypeResource.PAYMENT_METHODS,
+  notes: ActivityTypeResource.NOTES,
+  issuers: ActivityTypeResource.ISSUERS,
+  'covered-persons': ActivityTypeResource.COVERED_PERSONS,
+  kyc: ActivityTypeResource.KYCS,
+  aml: ActivityTypeResource.AMLS,
+  aic: ActivityTypeResource.AICS,
+  kyb: ActivityTypeResource.KYBS,
+  'legal-entities': ActivityTypeResource.LEGAL_ENTITIES,
+  accounts: ActivityTypeResource.ACCOUNTS,
+  files: ActivityTypeResource.FILES,
+  'files-public': ActivityTypeResource.FILES,
+  pages: ActivityTypeResource.PAGES,
+  disbursements: ActivityTypeResource.DISBURSEMENTS,
+  'disbursement-reviews': ActivityTypeResource.DISBURSEMENT_REVIEWS,
+  sites: ActivityTypeResource.SITES,
+  themes: ActivityTypeResource.THEMES,
+  'theme-settings': ActivityTypeResource.THEME_SETTINGS,
+};
+
+/**
+ * WARNING!!!
+ * ANY CHANGES TO:
+ * - ActivityTypeAction
+ * Will require a migration to add the new combinations to the database. See activity-type.entity.ts
+ * Also, previous migrations will have to be updated to prevent the new combination from being seeded before the new migration introduces it.
+ * see:
+ * SeedActivityActionTable1733789494520
+ * SeedActivityResourceTableFiles1735884938590
+ * SeedAmlPagesInActivityTypes1740995815856
+ * SeedActivityResourceTypeDisbursement1742689286845
+ * SeedActivityResourceTradeLineItem1746449328700
+ * SeedActivityReset2faAction1746791323564
+ * SeedActivityResourceUserCombinations1747289941817
+ * AddedResubmitActivityType1747999619404
+ * AddedDeclinedAndSignedActivityAction1748011929459
+ * SeedActivityResourceTypeDisbursementReview1753945998383
+ * SeedActivityResourceTypeTransaction1754457409040
+ * AddedAicTargetTable1756265520122
+ * AddedReporcessActivityTypeAction1758023244400
+ * AddedActivityActionSave1761715000038
+ * AddedAcceptedActivityAction1762848949484
+ */
+export enum ActivityTypeAction {
+  CREATE = BaseAction.CREATE,
+  UPDATE = BaseAction.UPDATE,
+  DELETE = BaseAction.DELETE,
+  IMPORT = BaseAction.IMPORT,
+  APPROVED = BaseStatus.APPROVED,
+  REJECTED = BaseStatus.REJECTED,
+  SUBMITTED = BaseStatus.SUBMITTED,
+  DECLINED = BaseStatus.DECLINED,
+  SIGNED = BaseStatus.SIGNED,
+  COMPLETED = BaseStatus.COMPLETED,
+  RE_SIGN = BaseStatus.RE_SIGN,
+  RESUBMIT = BaseStatus.RESUBMIT,
+  RESET_2FA = BaseStatus.RESET_2FA,
+  LOGIN = BaseStatus.LOGIN,
+  RESET_PASSWORD = BaseStatus.RESET_PASSWORD,
+  TWO_FACTOR_LOGIN = BaseStatus.TWO_FACTOR_LOGIN,
+  FORGOT_PASSWORD = BaseStatus.FORGOT_PASSWORD,
+  RE_PROCESS = BaseStatus.RE_PROCESS,
+  SAVE = BaseStatus.SAVE,
+  ACCEPTED = BaseStatus.ACCEPTED,
+  JOIN = BaseStatus.JOIN,
+  RESTORE = BaseStatus.RESTORE,
+}
+
+export const MethodMap: { [key: string]: ActivityTypeAction } = {
+  POST: ActivityTypeAction.CREATE,
+  PUT: ActivityTypeAction.UPDATE,
+  PATCH: ActivityTypeAction.UPDATE,
+  DELETE: ActivityTypeAction.DELETE,
+};
+
+export const activityIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'activity';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid activity ID format. Must be a valid TypeID with "activity" prefix. Example: activity_01j5y5ghx8fvc83dmx3pznq7hv',
+  },
+);
+
+export const UserLoginForActivityZod = z.object({
+  id: z.string().openapi({
+    example: 'user_login_01jepymte1feb8a4j46gy6850k',
+  }),
+  firstName: z.string().openapi({
+    example: 'Daniel',
+  }),
+  lastName: z.string().openapi({
+    example: 'Ice',
+  }),
+  email: z.string().email().openapi({
+    example: 'dice@dalmoregroup.com',
+  }),
+  __entity: z.string().optional(),
+});
+
+const UserForActivityZod = z.object({
+  id: z.string(),
+  roleId: z.string().nullable(),
+  accountId: z.string().nullable(),
+  userLogin: UserLoginForActivityZod,
+  __entity: z.string().optional(),
+});
+
+const ActivityTypeZod = IBaseEntity.extend({
+  category: z.nativeEnum(ActivityTypeCategory),
+  resource: z.enum(TargetTableEnum),
+  action: z.nativeEnum(ActivityTypeAction),
+  __entity: z.string().optional(),
+});
+
+export const ActivityZod = IBaseEntity.extend({
+  id: activityIdSchema,
+  message: z.string(),
+  targetTable: z.enum(TargetTableEnum),
+  targetId: z.string(),
+  userId: z.string().nullable(),
+  activityTypeId: z.string(),
+  accountId: z.string().nullable(),
+  user: UserForActivityZod,
+  activityType: ActivityTypeZod,
+  targetObject: z.string().nullable().optional(),
+  __entity: z.string().optional(),
+});
+export type ActivityZod = z.infer<typeof ActivityZod>;
+
+export const IPaginatedActivity = z.object({
+  items: z.array(ActivityZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedActivity = z.infer<typeof IPaginatedActivity>;
+
+export const ActivitiesFilters = z.object({
+  targetTable: z.enum(TargetTableEnum).optional(),
+  targetId: z
+    .string()
+    .optional()
+    .openapi({
+      example: 'disbursement_01j6aqmtfyfwy9spjdcnh7yqk7',
+    })
+    .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`,
+      },
+    ),
+  search: z.string().max(50).optional(),
+  targetIds: z
+    .string()
+    .optional()
+    .openapi({
+      example:
+        'disbursement_01j6aqmtfyfwy9spjdcnh7yqk7,disbursement_01j6aqmtfyfwy9spjdcnh7yqk8',
+    })
+    .transform((str) => {
+      if (!str) return [];
+      // Split by comma, trim whitespace, and remove duplicates using Set
+      const ids = str.split(',').map((id) => id.trim());
+      return Array.from(new Set(ids));
+    })
+    .refine(
+      (value) => {
+        if (!value || value.length === 0) return true;
+
+        // Validate each ID
+        return value.every((id) => {
+          try {
+            const tid = TypeID.fromString(id);
+            return Object.values(TargetTableConfig).some(
+              (config) => config.idPrefix === tid.getType(),
+            );
+          } catch {
+            return false;
+          }
+        });
+      },
+      {
+        message: `Invalid target IDs. All IDs must match the corresponding table's ID prefix. Valid prefix: ${TargetTableEnum.toString().toLowerCase()}. Example: disbursement_01j6aqmtfyfwy9spjdcnh7yqk7`,
+      },
+    ),
+});
+export type ActivitiesFilters = z.infer<typeof ActivitiesFilters>;