@dalmore/api-contracts 0.0.0-dev.d30d175 → 0.0.0-dev.d6badc9

package/common/types/trade.types.ts

@@ -39,7 +39,7 @@ import {
 import {
   tradeLineItemIdSchema,
   TradeLineItemZod,
-} from './trade-line-item.type';
+} from './trade-line-item.types';
 import { TradeAdjustmentZod } from './trade-adjustment.type';
 import { TransactionZod } from './transaction.types';
 import { accountIdSchema } from './account.types';

package/common/types/transaction.types.ts

@@ -1,10 +1,11 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { TypeID } from 'typeid-js';
 import {
   dateSchema,
   InvestorAccountType,
   numberPrecisionSchema,
 } from './common.types';
-import { z } from 'zod';
 import { IBaseEntity } from './entity.types';
 import { accountIdSchema } from './account.types';
 import {
@@ -18,7 +19,9 @@ import {
   investorAccountIdSchema,
 } from './investor-account.types';
 import { TransactionStatus, TransactionType } from './common.types';
+import { userIdSchema } from './user.types';
 export { TransactionStatus, TransactionType };
+extendZodWithOpenApi(z);
 
 export enum RefundPaymentMethod {
   CHECK = 'CHECK',
@@ -115,6 +118,14 @@ export type InvestorPostTransactionZod = z.infer<
   typeof InvestorPostTransactionZod
 >;
 
+export const ClientPostTransactionZod = InvestorPostTransactionZod.extend({
+  userId: z
+    .lazy(() => userIdSchema)
+    .openapi({ example: 'user_01j5y5ghx5fg68d663j1fvy2x7' }),
+});
+
+export type ClientPostTransactionZod = z.infer<typeof ClientPostTransactionZod>;
+
 export const refundTransactionIdSchema = z.string().refine(
   (value) => {
     try {

package/common/types/user.types.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import {
   AccountStatus,
   AccountWithoutUsersZod,
@@ -7,12 +8,11 @@ import {
   ManagedByType,
   OfferingType,
   PortalType,
+  StringToBooleanSchema,
   UserRole,
-  UserStatus,
   UserType,
 } from './common.types';
 import { dateOrString, IBaseEntity } from './entity.types';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
 import { PhoneZodSchema } from './phone.type';
 import { IInvestorAccount } from './investor-account.types';
 import { TradeZod } from './trade.types';
@@ -51,6 +51,11 @@ export const UserDeleteResponse = z.object({
 });
 export type UserDeleteResponse = z.infer<typeof UserDeleteResponse>;
 
+export const UserRestoreResponse = z.object({
+  message: z.string(),
+});
+export type UserRestoreResponse = z.infer<typeof UserRestoreResponse>;
+
 export const GetMeResponse = IBaseEntity.extend({
   accountId: z.string().nullable(),
   accountName: z.string().nullable(),
@@ -59,7 +64,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(),
@@ -157,7 +162,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(),
@@ -179,27 +184,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']);
@@ -274,7 +261,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>;
@@ -285,7 +272,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>;
 
@@ -299,7 +286,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/cart/index.ts

@@ -0,0 +1,80 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  BadRequestError,
+  InternalError,
+  TradeZod,
+  userIdSchema,
+  tradeIdSchema,
+} from '../../../common/types';
+import {
+  PatchCartBody,
+  ClientPlacetradeBody,
+  PlaceTradeResponse,
+} from '../../../common/types/cart.types';
+
+const c = initContract();
+
+export const cartContract = c.router(
+  {
+    getTradeCart: {
+      summary: 'Get carts (Trade.status = CART)',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postCheckout: {
+      summary: 'Place a trade (checkout button)',
+      method: 'POST',
+      path: '/checkout',
+      metadata: {
+        auth: true,
+      },
+      body: ClientPlacetradeBody,
+      responses: {
+        200: PlaceTradeResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    patchCart: {
+      summary: 'Patch a cart',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      body: PatchCartBody,
+      responses: {
+        200: TradeZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'carts',
+  },
+);

package/contracts/clients/index.ts

@@ -3,6 +3,7 @@ import { accountsContract } from './accounts';
 import { apiKeysContract } from './api-keys';
 import { clientApiKeyLogsContract } from './api-key-logs';
 import { assetsContract } from './assets';
+import { cartContract } from './cart';
 import { filesContract } from './files';
 import { individualsContract } from './individuals';
 import { investorAccountsContract } from './investor-accounts';
@@ -15,6 +16,10 @@ import { secureRequestContract } from './secure-requests';
 import { aicContract } from './aic';
 import { authContract } from './auth';
 import { sitesContract } from './sites';
+import { paymentMethodsContract } from './payment-methods';
+import { issuerPaymentMethodsContract } from './issuer-payment-methods';
+import { tradeLineItemsContract } from './trade-line-items';
+import { clientsTransactionsContract } from './transactions';
 
 const c = initContract();
 
@@ -27,16 +32,21 @@ export const clientsContract = c.router(
     apiKeys: apiKeysContract,
     apiKeyLogs: clientApiKeyLogsContract,
     assets: assetsContract,
+    cart: cartContract,
     files: filesContract,
     filesPublic: filesPublicContract,
     individuals: individualsContract,
     investorAccounts: investorAccountsContract,
+    issuerPaymentMethods: issuerPaymentMethodsContract,
     issuers: issuersContract,
     legalEntities: legalEntityContract,
     offerings: offeringsContract,
+    paymentMethods: paymentMethodsContract,
     secureRequests: secureRequestContract,
     sites: sitesContract,
+    tradeLineItems: tradeLineItemsContract,
     trades: tradesContract,
+    transactions: clientsTransactionsContract,
   },
   {
     pathPrefix: '/clients/api/v1/',

package/contracts/clients/issuer-payment-methods/index.ts

@@ -0,0 +1,39 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  GetIssuerPaymentMethodZod,
+  IPaginatedIssuerPaymentMethod,
+  IssuerPaymentMethodsIncludeQuery,
+  PaginationOptionsZod,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerPaymentMethodsContract = c.router(
+  {
+    getIssuerPaymentMethods: {
+      summary: 'Get issuer payment methods',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod).merge(
+        IssuerPaymentMethodsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuer-payment-methods',
+  },
+);

package/contracts/clients/payment-methods/index.ts

@@ -0,0 +1,85 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  userIdSchema,
+  BadRequestError,
+  InternalError,
+} from '../../../common/types';
+import {
+  PaymentMethodResponseArray,
+  PaymentMethodResponse,
+  PostPaymentMethod,
+  PostSetupIntentBody,
+  SetupIntentResponse,
+} from '../../../common/types/payment-methods.types';
+
+const c = initContract();
+
+export const paymentMethodsContract = c.router(
+  {
+    getPaymentMethods: {
+      summary: 'Get payment methods for a user',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: PaymentMethodResponseArray,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createPaymentMethod: {
+      summary: 'Create payment method for a user',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostPaymentMethod,
+      responses: {
+        201: PaymentMethodResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createSetupIntent: {
+      summary: 'Create payment method setup intent for a user',
+      method: 'POST',
+      path: '/intent',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostSetupIntentBody,
+      responses: {
+        201: SetupIntentResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'payment-methods',
+  },
+);

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

@@ -0,0 +1,66 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  userIdSchema,
+} from '../../../common/types';
+import {
+  PostTradeLineItem,
+  TradeLineItemParams,
+  TradeLineItemQuery,
+  TradeLineItemResponse,
+  TradeLineItemUpdate,
+} from '../../../common/types/trade-line-item.types';
+
+const c = initContract();
+
+export const tradeLineItemsContract = c.router(
+  {
+    postTradeLineItem: {
+      summary: 'Create Trade Line Item',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostTradeLineItem,
+      query: TradeLineItemQuery.merge(
+        z.object({
+          userId: userIdSchema,
+        }),
+      ),
+      responses: {
+        201: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    updateTradeLineItem: {
+      summary: 'Update Trade Line Item - Can delete if you pass quantity = 0',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: TradeLineItemParams,
+      body: TradeLineItemUpdate,
+      responses: {
+        200: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+        400: BadRequestError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trade-line-items',
+  },
+);

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/clients/transactions/index.ts

@@ -0,0 +1,37 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  ClientPostTransactionZod,
+  TransactionZod,
+} from '../../../common/types/transaction.types';
+
+const c = initContract();
+
+export const clientsTransactionsContract = c.router(
+  {
+    postTransaction: {
+      summary: 'Create a transaction',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: ClientPostTransactionZod,
+      responses: {
+        201: TransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'transactions',
+  },
+);

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/bonus-tiers/index.ts

@@ -6,10 +6,12 @@ import {
   UnauthorizedError,
 } from '../../../common/types';
 import {
+  ComplianceEstimateBonusTierCalculationZod,
   CompliancePostBonusTierZod,
   EstimateBonusTierCalculationResponseZod,
-  EstimateBonusTierCalculationZod,
   IBonusTierList,
+  PurchaseCalculationResponseZod,
+  PurchaseCalculationZod,
 } from '../../../common/types/bonus-tier.types';
 
 const c = initContract();
@@ -23,7 +25,7 @@ export const bonusTiersContract = c.router(
       metadata: {
         auth: true,
       },
-      body: EstimateBonusTierCalculationZod,
+      body: ComplianceEstimateBonusTierCalculationZod,
       responses: {
         200: EstimateBonusTierCalculationResponseZod,
         400: BadRequestError,
@@ -32,6 +34,23 @@ export const bonusTiersContract = c.router(
         500: InternalError,
       },
     },
+    purchaseCalculation: {
+      summary:
+        '[ADMIN] Calculate the bonus shares that would be awarded for a trade',
+      method: 'POST',
+      path: '/purchase-calculation',
+      metadata: {
+        auth: true,
+      },
+      body: PurchaseCalculationZod,
+      responses: {
+        200: PurchaseCalculationResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
     postBonusTier: {
       summary: 'Create a new bonus tier',
       method: 'POST',

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,