@dalmore/api-contracts 0.0.0-dev.d8ef117 → 0.0.0-dev.e6235a7

package/common/types/trusted-contact.types.ts

@@ -2,7 +2,11 @@ import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { TypeID } from 'typeid-js';
 import { z } from 'zod';
 import { IBaseEntity } from './entity.types';
-import { IPaginationMeta, TrustedContactRelationship } from './common.types';
+import {
+  EmailSchema,
+  IPaginationMeta,
+  TrustedContactRelationship,
+} from './common.types';
 import { PhoneZodSchema } from './phone.type';
 import { AddressSchema } from './address.types';
 import { investorAccountIdSchema } from './investor-account.types';
@@ -68,7 +72,7 @@ export const PostTrustedContactZod = z
   .object({
     firstName: z.string().min(1).max(255).openapi({ example: 'John' }),
     lastName: z.string().min(1).max(255).openapi({ example: 'Doe' }),
-    email: z.string().email().openapi({ example: 'john.doe@example.com' }),
+    email: EmailSchema.openapi({ example: 'john.doe@example.com' }),
     phone: PhoneZodSchema.nullable().optional(),
     relationship: z
       .nativeEnum(TrustedContactRelationship)
@@ -92,11 +96,7 @@ export const PatchTrustedContactZod = z
       .optional()
       .openapi({ example: 'John' }),
     lastName: z.string().min(1).max(255).optional().openapi({ example: 'Doe' }),
-    email: z
-      .string()
-      .email()
-      .optional()
-      .openapi({ example: 'john.doe@example.com' }),
+    email: EmailSchema.optional(),
     phone: PhoneZodSchema.nullable().optional(),
     relationship: z.nativeEnum(TrustedContactRelationship).optional().openapi({
       example: TrustedContactRelationship.CHILD,

package/common/types/user.types.ts

@@ -8,9 +8,10 @@ import {
   ManagedByType,
   OfferingType,
   PortalType,
+  StringToBooleanSchema,
   UserRole,
-  UserStatus,
   UserType,
+  EmailSchema,
 } from './common.types';
 import { dateOrString, IBaseEntity } from './entity.types';
 import { PhoneZodSchema } from './phone.type';
@@ -64,7 +65,7 @@ export const GetMeResponse = IBaseEntity.extend({
   email: z.string().email(),
   provider: z.string(),
   active: z.boolean(),
-  status: z.lazy(() => z.nativeEnum(UserStatus)),
+  locked: z.boolean(),
   lastLoginAt: dateOrString.nullable(),
   loginCount: z.number(),
   role: z.string(),
@@ -147,11 +148,7 @@ export const UserMeUpdateZod = z.object({
   firstName: z.string().optional(),
   lastName: z.string().optional(),
   password: z.string().min(6).optional(),
-  email: z
-    .string()
-    .email()
-    .transform((val) => val.toLowerCase())
-    .optional(),
+  email: EmailSchema.optional(),
 });
 
 export const UserZod = IBaseEntity.extend({
@@ -162,7 +159,7 @@ export const UserZod = IBaseEntity.extend({
   onboarding: z.string().nullable(),
   account: AccountWithoutUsersZod.optional(),
   active: z.boolean(),
-  status: z.nativeEnum(UserStatus),
+  locked: z.boolean(),
   userLogin: IBaseEntity.extend({
     firstName: z.string(),
     lastName: z.string(),
@@ -184,27 +181,9 @@ export const UserFiltersZod = z.object({
   search: z.string().max(50).optional(),
   role: z.nativeEnum(UserRole).optional(),
   portal: z.string().optional(),
-  status: z.nativeEnum(UserStatus).optional(),
-  active: z
-    .string()
-    .optional()
-    .refine((v) => !v || v === 'true' || v === 'false', {
-      message: 'active must be a boolean string',
-    })
-    .transform((v) => {
-      if (!v) return undefined;
-      return v === 'true';
-    }),
-  twoFactorEnabled: z
-    .string()
-    .optional()
-    .refine((v) => !v || v === 'true' || v === 'false', {
-      message: 'twoFactorEnabled must be a boolean string',
-    })
-    .transform((v) => {
-      if (!v) return undefined;
-      return v === 'true';
-    }),
+  locked: StringToBooleanSchema.optional(),
+  active: StringToBooleanSchema.optional(),
+  twoFactorEnabled: StringToBooleanSchema.optional(),
 });
 
 const usersInclude = z.enum(['account', 'role']);
@@ -279,7 +258,7 @@ export type IssuerUsersStatusUpdateResponse = z.infer<
 >;
 
 export const UpdateLockedStatus = z.object({
-  status: z.nativeEnum(UserStatus),
+  locked: z.boolean(),
 });
 
 export type UpdateLockedStatus = z.infer<typeof UpdateLockedStatus>;
@@ -290,7 +269,7 @@ export const UsersSummaryFilterZod = z.object({
   portalType: z.nativeEnum(PortalType).optional(),
   search: z.string().trim().max(50).optional(),
   selectRole: z.nativeEnum(UserRole).optional(),
-  status: z.nativeEnum(UserStatus).optional(),
+  locked: StringToBooleanSchema.optional(),
 });
 export type UsersSummaryFilterZod = z.infer<typeof UsersSummaryFilterZod>;
 
@@ -304,7 +283,7 @@ export const UsersSummaryZod = z.object({
   portalType: z.string(),
   loginCount: z.number().int(),
   lastLogin: z.date(),
-  status: z.nativeEnum(UserStatus),
+  locked: z.boolean(),
 });
 export type UsersSummaryZod = z.infer<typeof UsersSummaryZod>;
 

package/contracts/clients/trade-line-items/index.ts

@@ -14,7 +14,7 @@ import {
   TradeLineItemQuery,
   TradeLineItemResponse,
   TradeLineItemUpdate,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 

package/contracts/clients/trades/index.ts

@@ -26,7 +26,7 @@ import {
   PostTradeLineItem,
   TradeLineItemQuery,
   TradeLineItemResponse,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 

package/contracts/compliance/account-settings/index.ts

@@ -0,0 +1,59 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  accountSettingIdSchema,
+  AccountSettingsFilters,
+  AccountSettingsIncludeQuery,
+  IAccountSettingZod,
+  IPaginatedAccountSetting,
+} from '../../../common/types/account-setting.types';
+import {
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const accountSettingsContract = c.router(
+  {
+    getAccountSettings: {
+      summary: 'Get account settings',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(AccountSettingsFilters).merge(
+        AccountSettingsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedAccountSetting,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    getAccountSetting: {
+      summary: 'Get account setting by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountSettingIdSchema,
+      }),
+      query: z.object({}).merge(AccountSettingsIncludeQuery),
+      responses: {
+        200: IAccountSettingZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'account-settings',
+  },
+);

package/contracts/compliance/auth/index.ts

@@ -10,6 +10,7 @@ import {
   LoginBody2FA,
   NotFoundError,
   UnauthorizedError,
+  EmailSchema,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -49,7 +50,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'forgot-password',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
       }),
       responses: {
         200: null,
@@ -75,7 +76,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'reset-password/verify',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
         code: z.string(),
       }),
       responses: {
@@ -90,7 +91,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'reset-password',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
         code: z.string(),
         password: z.string().min(6),
       }),

package/contracts/compliance/bonus-tiers/index.ts

@@ -6,9 +6,9 @@ import {
   UnauthorizedError,
 } from '../../../common/types';
 import {
+  ComplianceEstimateBonusTierCalculationZod,
   CompliancePostBonusTierZod,
   EstimateBonusTierCalculationResponseZod,
-  EstimateBonusTierCalculationZod,
   IBonusTierList,
   PurchaseCalculationResponseZod,
   PurchaseCalculationZod,
@@ -25,7 +25,7 @@ export const bonusTiersContract = c.router(
       metadata: {
         auth: true,
       },
-      body: EstimateBonusTierCalculationZod,
+      body: ComplianceEstimateBonusTierCalculationZod,
       responses: {
         200: EstimateBonusTierCalculationResponseZod,
         400: BadRequestError,

package/contracts/compliance/index.ts

@@ -1,6 +1,7 @@
 import { accountsContract } from './accounts';
 import { accountContactsContract } from './account-contacts';
 import { accountManagersContract } from './account-managers';
+import { accountSettingsContract } from './account-settings';
 import { activitiesContract } from './activities';
 import { apiKeysContract } from './api-keys';
 import { assetsContract } from './assets';
@@ -31,6 +32,7 @@ import { kycsContract } from './kyc';
 import { legalEntitiesContract } from './legal-entities';
 import { loginHistoriesContract } from './login-histories';
 import { notesContract } from './notes';
+import { notificationChannelsContract } from './notification-channels';
 import { offeringsContract } from './offerings';
 import { pagesContract } from './pages';
 import { paymentMethodsContract } from './payment-methods';
@@ -75,6 +77,7 @@ export const complianceContract = c.router(
     accounts: accountsContract,
     accountContacts: accountContactsContract,
     accountManagers: accountManagersContract,
+    accountSettings: accountSettingsContract,
     activities: activitiesContract,
     apiKeys: apiKeysContract,
     assets: assetsContract,
@@ -112,6 +115,7 @@ export const complianceContract = c.router(
     legalEntities: legalEntitiesContract,
     loginHistories: loginHistoriesContract,
     notes: notesContract,
+    notificationChannels: notificationChannelsContract,
     offerings: offeringsContract,
     pages: pagesContract,
     paymentMethods: paymentMethodsContract,

package/contracts/compliance/invites/index.ts

@@ -1,6 +1,7 @@
 import { initContract } from '@ts-rest/core';
 import {
   BadRequestError,
+  CompliancePostInviteZod,
   ForbiddenError,
   InternalError,
   inviteIdSchema,
@@ -10,9 +11,8 @@ import {
   NotFoundError,
   PaginationOptionsZod,
   PatchInviteForComplianceZod,
-  PortalType,
+  PostInviteZod,
   UnauthorizedError,
-  UserRole,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -42,12 +42,7 @@ export const invitesContract = c.router(
       metadata: {
         auth: true,
       },
-      body: z.object({
-        email: z.string().email(),
-        role: z.nativeEnum(UserRole),
-        accountId: z.string().optional(),
-        portalType: z.nativeEnum(PortalType).optional(),
-      }),
+      body: PostInviteZod,
       responses: {
         201: InviteWithUrl,
         400: BadRequestError,
@@ -62,10 +57,7 @@ export const invitesContract = c.router(
       metadata: {
         auth: true,
       },
-      body: z.object({
-        email: z.string().email(),
-        role: z.nativeEnum(UserRole),
-      }),
+      body: CompliancePostInviteZod,
       responses: {
         201: InviteWithUrl,
         400: BadRequestError,

package/contracts/compliance/notification-channels/index.ts

@@ -0,0 +1,251 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  CreateChannelInputSchema,
+  CreateTriggerInputSchema,
+  IAvailableTriggersResponse,
+  INotificationChannelTriggerZod,
+  INotificationChannelZod,
+  INotificationRecordZod,
+  IPaginatedNotificationChannel,
+  IPaginatedNotificationRecord,
+  NotificationChannelFilters,
+  NotificationChannelsIncludeQuery,
+  notificationChannelIdSchema,
+  notificationChannelTriggerIdSchema,
+  NotificationRecordFilters,
+  NotificationRecordsIncludeQuery,
+  notificationRecordIdSchema,
+  UpdateChannelInputSchema,
+} from '../../../common/types/notification.types';
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const notificationChannelsContract = c.router(
+  {
+    getChannels: {
+      summary: 'Get notification channels',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(NotificationChannelFilters).merge(
+        NotificationChannelsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedNotificationChannel,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    getChannel: {
+      summary: 'Get notification channel by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: notificationChannelIdSchema,
+      }),
+      query: z.object({}).merge(NotificationChannelsIncludeQuery),
+      responses: {
+        200: INotificationChannelZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createChannel: {
+      summary: 'Create notification channel',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: CreateChannelInputSchema,
+      responses: {
+        201: INotificationChannelZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    updateChannel: {
+      summary: 'Update notification channel',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: notificationChannelIdSchema,
+      }),
+      body: UpdateChannelInputSchema,
+      responses: {
+        200: INotificationChannelZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deleteChannel: {
+      summary: 'Delete notification channel',
+      method: 'DELETE',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: notificationChannelIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createTrigger: {
+      summary: 'Create notification channel trigger',
+      method: 'POST',
+      path: '/:id/triggers',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: notificationChannelIdSchema,
+      }),
+      body: CreateTriggerInputSchema.omit({ notificationChannelId: true }),
+      responses: {
+        201: INotificationChannelTriggerZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getAvailableTriggers: {
+      summary: 'Get all available triggers for a channel',
+      method: 'GET',
+      path: '/:id/triggers/available',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: notificationChannelIdSchema,
+      }),
+      responses: {
+        200: IAvailableTriggersResponse,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateTrigger: {
+      summary: 'Update notification channel trigger',
+      method: 'PATCH',
+      path: '/:id/triggers/:triggerId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: notificationChannelIdSchema,
+        triggerId: notificationChannelTriggerIdSchema,
+      }),
+      body: z.object({ enabled: z.boolean() }),
+      responses: {
+        200: INotificationChannelTriggerZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deleteTrigger: {
+      summary: 'Delete notification channel trigger',
+      method: 'DELETE',
+      path: '/:id/triggers/:triggerId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: notificationChannelIdSchema,
+        triggerId: notificationChannelTriggerIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getRecords: {
+      summary: 'Get notification records',
+      method: 'GET',
+      path: '/records',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(NotificationRecordFilters).merge(
+        NotificationRecordsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedNotificationRecord,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    getRecord: {
+      summary: 'Get notification record by id',
+      method: 'GET',
+      path: '/records/:recordId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        recordId: notificationRecordIdSchema,
+      }),
+      query: z.object({}).merge(NotificationRecordsIncludeQuery),
+      responses: {
+        200: INotificationRecordZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    retryRecord: {
+      summary: 'Retry failed notification record',
+      method: 'POST',
+      path: '/records/:recordId/retry',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        recordId: notificationRecordIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: INotificationRecordZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'notification-channels',
+  },
+);

package/contracts/compliance/trade-line-items/index.ts

@@ -13,7 +13,7 @@ import {
   ReviewTradeLineItemStatus,
   TradeLineItemFiltersQuery,
   TradeLineItemResponse,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 import { z } from 'zod';
 const c = initContract();

package/contracts/investors/trade-line-items/index.ts

@@ -13,7 +13,7 @@ import {
   TradeLineItemResponse,
   TradeLineItemUpdate,
   TradeLineItemSignStatusUpdate,
-} from '../../../common/types/trade-line-item.type';
+} from '../../../common/types/trade-line-item.types';
 
 const c = initContract();
 

package/contracts/issuers/account-settings/index.ts

@@ -0,0 +1,36 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  AccountSettingsIncludeQuery,
+  IAccountSettingZod,
+} from '../../../common/types/account-setting.types';
+import {
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerAccountSettingsContract = c.router(
+  {
+    getAccountSettings: {
+      summary: 'Get account settings for current account',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(AccountSettingsIncludeQuery),
+      responses: {
+        200: IAccountSettingZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'account-settings',
+  },
+);

package/contracts/issuers/auth/index.ts

@@ -13,6 +13,7 @@ import {
   SelectAccountIssuersResponse,
   SwitchAccountIssuersBody,
   UnauthorizedError,
+  EmailSchema,
 } from '../../../common/types';
 import { z } from 'zod';
 
@@ -78,7 +79,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'forgot-password',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
       }),
       responses: {
         200: z.string(),
@@ -92,7 +93,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'reset-password/verify',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
         code: z.string(),
       }),
       responses: {
@@ -108,7 +109,7 @@ export const authContract = c.router(
       method: 'POST',
       path: 'reset-password',
       body: z.object({
-        email: z.string().email(),
+        email: EmailSchema,
         code: z.string(),
         password: z.string().min(6),
       }),