@dalmore/api-contracts 0.0.0-dev.2dc8e92

package/contracts/compliance-apikey/accounts/index.ts

@@ -0,0 +1,58 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedAccount,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  AccountFiltersZod,
+  AccountsIncludeQuery,
+  AccountZod,
+  accountIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const accountsContract = c.router(
+  {
+    getAccount: {
+      summary: 'Get account by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(AccountsIncludeQuery),
+      pathParams: z.object({
+        id: accountIdSchema,
+      }),
+      responses: {
+        200: AccountZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getAccounts: {
+      summary: 'Get accounts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(AccountFiltersZod).merge(
+          AccountsIncludeQuery,
+        ),
+      responses: {
+        200: IPaginatedAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'accounts',
+  },
+);

package/contracts/compliance-apikey/index.ts

@@ -0,0 +1,14 @@
+import { initContract } from '@ts-rest/core';
+import { accountsContract } from './accounts';
+
+const c = initContract();
+
+// API KEY AUTH
+export const complianceApiKeyContract = c.router(
+  {
+    accounts: accountsContract,
+  },
+  {
+    pathPrefix: '/compliance-apikey/api/v1/',
+  },
+);

package/contracts/index.ts

@@ -0,0 +1,6 @@
+export * from './compliance';
+export * from './issuers';
+export * from './investors';
+export * from './clients';
+export * from './secondaries';
+export * from './compliance-apikey';

package/contracts/investors/account-contacts/index.ts

@@ -0,0 +1,58 @@
+import { initContract } from '@ts-rest/core';
+import {
+  accountIdSchema,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  accountContactIdSchema,
+  IAccountContact,
+} from '../../../common/types/account-contact.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const accountContactsContract = c.router(
+  {
+    getAccountContacts: {
+      summary: 'Get Account Contacts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        accountId: accountIdSchema,
+      }),
+      responses: {
+        200: z.array(IAccountContact),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAccountContact: {
+      summary: 'Get account contact by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountContactIdSchema,
+      }),
+      responses: {
+        200: IAccountContact,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'account-contacts',
+  },
+);

package/contracts/investors/aic/index.ts

@@ -0,0 +1,59 @@
+import { initContract } from '@ts-rest/core';
+import {
+  AicIncludeQuery,
+  AicZod,
+  AttachAicFileBodyZod,
+  BadRequestError,
+  ForbiddenError,
+  individualIdSchema,
+  InternalError,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+export const aicContract = c.router(
+  {
+    getAic: {
+      summary: 'Get AIC',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        individualId: individualIdSchema,
+      }),
+      query: AicIncludeQuery,
+      responses: {
+        200: AicZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    attachAicFile: {
+      summary: 'Attach AIC File',
+      method: 'PUT',
+      path: '/file',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        individualId: individualIdSchema,
+      }),
+      body: AttachAicFileBodyZod,
+      responses: {
+        200: AicZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'individual/:individualId/aic',
+  },
+);

package/contracts/investors/assets/index.ts

@@ -0,0 +1,61 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  AssetFiltersZod,
+  assetIdSchema,
+  AssetsIncludeQuery,
+  IAsset,
+  IPaginatedAsset,
+} from '../../../common/types/asset.types';
+
+const c = initContract();
+
+export const assetsContract = c.router(
+  {
+    getAssets: {
+      summary: 'Get assets',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(AssetsIncludeQuery).merge(AssetFiltersZod),
+      responses: {
+        200: IPaginatedAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getAsset: {
+      summary: 'Get asset by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: AssetsIncludeQuery,
+      pathParams: z.object({
+        id: assetIdSchema,
+      }),
+      responses: {
+        200: IAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'assets',
+  },
+);

package/contracts/investors/auth/index.ts

@@ -0,0 +1,116 @@
+import { initContract } from '@ts-rest/core';
+import {
+  AccessTokenResponse,
+  AuthSuccessResponse,
+  BadRequestError,
+  IChangePasswordBodyZod,
+  InternalError,
+  InvestorForgotPasswordRequestZod,
+  LoginBody2FA,
+  LoginBodyInvestors,
+  NotFoundError,
+  RegisterBodyInvestors,
+  ResetPasswordBody,
+  ResetPasswordVerifyBody,
+  ResetPasswordVerifyResponse,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const authContract = c.router(
+  {
+    registerEmail: {
+      summary: 'Register with email',
+      method: 'POST',
+      path: 'register/email',
+      body: RegisterBodyInvestors,
+      responses: {
+        201: AccessTokenResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    loginEmail: {
+      summary: 'Login with email',
+      method: 'POST',
+      path: 'login/email',
+      headers: z.object({
+        'user-agent': z.string(),
+      }),
+      body: LoginBodyInvestors,
+      responses: {
+        200: AccessTokenResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    forgotPassword: {
+      summary: 'Forgot password',
+      method: 'POST',
+      path: 'forgot-password',
+      body: InvestorForgotPasswordRequestZod,
+      responses: {
+        200: AuthSuccessResponse,
+        400: BadRequestError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    resetPasswordVerify: {
+      summary: 'Reset password verify',
+      method: 'POST',
+      path: 'reset-password/verify',
+      body: ResetPasswordVerifyBody,
+      responses: {
+        200: ResetPasswordVerifyResponse,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    resetPassword: {
+      summary: 'Reset password',
+      method: 'POST',
+      path: 'reset-password',
+      body: ResetPasswordBody,
+      responses: {
+        200: AuthSuccessResponse,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    changePassword: {
+      summary: 'Change password',
+      method: 'POST',
+      path: 'change-password',
+      body: IChangePasswordBodyZod,
+      responses: {
+        201: AuthSuccessResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    loginEmailTwoFactor: {
+      summary: 'Login with email and 2FA',
+      method: 'POST',
+      path: 'login/email/2fa',
+      headers: z.object({
+        'user-agent': z.string(),
+      }),
+      body: LoginBody2FA,
+      responses: {
+        200: AccessTokenResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'auth/',
+  },
+);

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

@@ -0,0 +1,37 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  EstimateBonusTierCalculationResponseZod,
+  EstimateBonusTierCalculationZod,
+} from '../../../common/types/bonus-tier.types';
+
+const c = initContract();
+
+export const bonusTiersContract = c.router(
+  {
+    estimateCalculation: {
+      summary: 'Estimate bonus tier calculation',
+      method: 'POST',
+      path: '/estimate-calculation',
+      metadata: {
+        auth: true,
+      },
+      body: EstimateBonusTierCalculationZod,
+      responses: {
+        200: EstimateBonusTierCalculationResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'bonus-tiers',
+  },
+);

package/contracts/investors/cart/index.ts

@@ -0,0 +1,75 @@
+import { initContract } from '@ts-rest/core';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  InternalError,
+  BadRequestError,
+  TradeZod,
+  tradeIdSchema,
+} from '../../../common/types';
+import {
+  PlaceTradeResponse,
+  PlaceTradeBody,
+  PatchCartBody,
+} from '../../../common/types/cart.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const cartContract = c.router(
+  {
+    getTradeCart: {
+      summary: 'GET Cart (Trade.status = CART)',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    postCheckout: {
+      summary: 'Place a trade (checkout button)',
+      method: 'POST',
+      path: '/checkout',
+      metadata: {
+        auth: true,
+      },
+      body: PlaceTradeBody,
+      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/investors/contact-us/index.ts

@@ -0,0 +1,48 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  InvestorPostContactUsZod,
+  PostContactUsResponse,
+  PublicInvestorContactUsZod,
+} from '../../../common/types/contact-us.types';
+
+const c = initContract();
+
+export const contactUsContract = c.router(
+  {
+    postContactUsPublic: {
+      summary: 'Post Contact us for public users',
+      method: 'POST',
+      path: '/public',
+      body: PublicInvestorContactUsZod,
+      responses: {
+        201: PostContactUsResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    postContactUs: {
+      summary: 'Post Contact us',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: InvestorPostContactUsZod,
+      responses: {
+        201: PostContactUsResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'contact-us',
+  },
+);

package/contracts/investors/data-records/index.ts

@@ -0,0 +1,113 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  dataRecordIdSchema,
+  DataRecordsFilters,
+  DataRecordsIncludeQuery,
+  DataRecordStructureZod,
+  DataRecordZod,
+  IPaginatedDataRecords,
+  NavigationSummaryZod,
+  RecordPathResponse,
+} from '../../../common/types/data-record.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const dataRecordsContract = c.router(
+  {
+    getDataRecords: {
+      summary: 'Get Data Records',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(DataRecordsFilters).merge(
+        DataRecordsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedDataRecords,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getDataRecord: {
+      summary: 'Get data record by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: dataRecordIdSchema }),
+      query: DataRecordsIncludeQuery,
+      responses: {
+        200: DataRecordZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getDataRecordStructure: {
+      summary:
+        'Get data record structure by id - shows the proper tree structure of the data record',
+      method: 'GET',
+      path: '/:id/structure',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: dataRecordIdSchema }),
+      responses: {
+        200: DataRecordStructureZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getDataRecordPath: {
+      summary:
+        'Get data record path by id - useful for navigation and showing the user where they are in the folder structure. Returns the path to the record',
+      method: 'GET',
+      path: '/:id/path',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: dataRecordIdSchema }),
+      responses: {
+        200: RecordPathResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getNavigationSummary: {
+      summary:
+        'Get navigation summary for a data record - useful for breadcrumbs',
+      method: 'GET',
+      path: '/:id/navigation',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: dataRecordIdSchema }),
+      responses: {
+        200: NavigationSummaryZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'data-records',
+  },
+);