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

package/contracts/investors/portfolios/index.ts

@@ -0,0 +1,53 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+import { investorAccountIdSchema } from '../../../common/types/investor-account.types';
+import {
+  AccountPortfolioResponse,
+  TradeStatusBreakdownResponse,
+} from '../../../common/types/portfolio.types';
+
+const c = initContract();
+
+export const portfoliosContract = c.router(
+  {
+    getPortfolio: {
+      summary: 'GET portfolio',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: TradeStatusBreakdownResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAccountPortfolio: {
+      summary: 'GET Account portfolio',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: investorAccountIdSchema,
+      }),
+      responses: {
+        200: AccountPortfolioResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'portfolios',
+  },
+);

package/contracts/investors/sites/index.ts

@@ -0,0 +1,96 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  UrlSchema,
+  GetPasswordProtectionSettingsZod,
+  themeIdSchema,
+} from '../../../common/types';
+import {
+  DownloadThemeFileZod,
+  SiteConfigsZod,
+  SiteUrlsZod,
+  SiteUrlZod,
+  VerifyPasswordResponseZod,
+  VerifyPasswordZod,
+} from '../../../common/types/site.types';
+import { z } from 'zod';
+const c = initContract();
+
+export const sitesContract = c.router(
+  {
+    getPasswordProtectionSettings: {
+      summary: 'Get the password protection settings for the current account',
+      method: 'GET',
+      path: '/password-protection',
+      query: SiteUrlZod,
+      responses: {
+        200: GetPasswordProtectionSettingsZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getSiteUrls: {
+      summary: 'Get the urls for the site',
+      method: 'GET',
+      path: '/files-public/urls',
+      query: z.object({
+        url: UrlSchema,
+      }),
+      responses: {
+        200: SiteUrlsZod,
+        500: InternalError,
+      },
+    },
+    downloadThemeFile: {
+      summary: 'Preview a theme file',
+      method: 'GET',
+      path: '/download',
+      query: DownloadThemeFileZod,
+      responses: {
+        200: z.unknown(),
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    getSiteConfigs: {
+      summary: 'get site configs of a specific domain',
+      method: 'GET',
+      path: '/',
+      query: z.object({
+        url: UrlSchema,
+        themeId: z
+          .lazy(() => themeIdSchema)
+          .nullable()
+          .optional(),
+      }),
+      responses: {
+        200: SiteConfigsZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    verifyPassword: {
+      summary: 'Verify the password for the site',
+      method: 'POST',
+      path: '/verify-password',
+      query: SiteUrlZod,
+      body: VerifyPasswordZod,
+      responses: {
+        200: VerifyPasswordResponseZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'sites',
+  },
+);

package/contracts/investors/tasks/index.ts

@@ -0,0 +1,111 @@
+import { initContract } from '@ts-rest/core';
+import {
+  IPaginatedTask,
+  TaskZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  taskIdSchema,
+  InvestorsTaskFiltersZod,
+  TasksIncludeQuery,
+  PatchInvestorTaskZod,
+  InternalError,
+  MarkTaskAsDoneZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const tasksContract = c.router(
+  {
+    getTasks: {
+      summary: 'Get tasks',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(TasksIncludeQuery).merge(
+        InvestorsTaskFiltersZod,
+      ),
+      responses: {
+        200: IPaginatedTask,
+        401: UnauthorizedError,
+      },
+    },
+    getTask: {
+      summary: 'Get task by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: TasksIncludeQuery,
+      pathParams: z.object({
+        id: taskIdSchema,
+      }),
+      responses: {
+        200: TaskZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    patchTask: {
+      summary: 'Update task by id',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: taskIdSchema,
+      }),
+      body: PatchInvestorTaskZod,
+      responses: {
+        200: TaskZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    markTaskAsDone: {
+      summary: 'Mark task as done',
+      method: 'PATCH',
+      path: '/:id/done',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: taskIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: MarkTaskAsDoneZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    markTaskAsViewed: {
+      summary: 'Mark task as viewed',
+      method: 'PATCH',
+      path: '/:id/viewed',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: taskIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: MarkTaskAsDoneZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'tasks',
+  },
+);

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

@@ -0,0 +1,75 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  TradeLineItemParams,
+  PostTradeLineItem,
+  TradeLineItemQuery,
+  TradeLineItemResponse,
+  TradeLineItemUpdate,
+  TradeLineItemSignStatusUpdate,
+} from '../../../common/types/trade-line-item.type';
+
+const c = initContract();
+
+export const tradeLineItemsContract = c.router(
+  {
+    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,
+      },
+    },
+    postTradeLineItem: {
+      summary: 'Create Trade Line Item',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostTradeLineItem,
+      query: TradeLineItemQuery,
+      responses: {
+        201: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    updateLineItemSignatureStatus: {
+      summary: 'Update Trade Signature Status',
+      method: 'PATCH',
+      path: '/:id/sign',
+      metadata: { auth: true },
+      body: TradeLineItemSignStatusUpdate,
+      responses: {
+        200: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trade-line-items',
+  },
+);

package/contracts/investors/trades/index.ts

@@ -0,0 +1,114 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  InvestorsGetTradesQuery,
+  InvestorsPaginatedTrade,
+  InvestorsTradeResponse,
+  PostTradeBody,
+  tradeIdSchema,
+  TradeZod,
+  UpdateTradeBody,
+  CancelTradeResponse,
+  CancelTradeZod,
+} from '../../../common/types/trade.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const tradesContract = c.router(
+  {
+    getTrades: {
+      summary: 'Get trades',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: InvestorsGetTradesQuery,
+      responses: {
+        200: InvestorsPaginatedTrade,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    createTrades: {
+      summary: 'Create Trades',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostTradeBody,
+      responses: {
+        201: InvestorsTradeResponse,
+        500: InternalError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    updateTradePaymentMethod: {
+      summary: 'Update Trade Payment Method',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      body: UpdateTradeBody,
+      responses: {
+        200: InvestorsTradeResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getTrade: {
+      summary: 'GET Trade by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      responses: {
+        200: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    cancelTrade: {
+      summary: 'Cancel Trade',
+      method: 'PUT',
+      path: '/:id/cancel',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      body: CancelTradeZod,
+      responses: {
+        201: CancelTradeResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trades',
+  },
+);

package/contracts/investors/transactions/index.ts

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

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

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  GetTrustedContactFilters,
+  IPaginatedTrustedContact,
+  ITrustedContactZod,
+  PatchTrustedContactZod,
+  PostTrustedContactZod,
+  trustedContactIdSchema,
+  TrustedContactsIncludeQuery,
+} from '../../../common/types/trusted-contact.types';
+const c = initContract();
+
+export const trustedContactsContract = c.router(
+  {
+    getTrustedContacts: {
+      summary: 'Get Trusted Contacts of an investor account',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(GetTrustedContactFilters),
+      responses: {
+        200: IPaginatedTrustedContact,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    postTrustedContact: {
+      summary: 'Create a trusted contact for an investor account',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostTrustedContactZod,
+      responses: {
+        201: ITrustedContactZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getTrustedContact: {
+      summary: 'Get trusted contact of an investor account by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(TrustedContactsIncludeQuery),
+      pathParams: z.object({ id: trustedContactIdSchema }),
+      responses: {
+        200: ITrustedContactZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    patchTrustedContact: {
+      summary: 'Update trusted contact of an investor account by id',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: trustedContactIdSchema,
+      }),
+      body: PatchTrustedContactZod,
+      responses: {
+        201: ITrustedContactZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trusted-contacts',
+  },
+);

package/contracts/investors/user-manuals/index.ts

@@ -0,0 +1,62 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  IPaginatedUserManualCategory,
+  IUserManualCategory,
+  userManualCategoriesIncludeQuery,
+  userManualCategorySchema,
+  GetLimitedUserManualCategoryZod,
+  UserManualsPaginationOptionsZod,
+} from '../../../common/types/user-manual.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const userManualsContract = c.router(
+  {
+    getUserManualCategories: {
+      summary: 'Get user manual Categories',
+      method: 'GET',
+      path: '/categories',
+      metadata: {
+        auth: true,
+      },
+      query: UserManualsPaginationOptionsZod.merge(
+        userManualCategoriesIncludeQuery,
+      ).merge(GetLimitedUserManualCategoryZod),
+      responses: {
+        200: IPaginatedUserManualCategory,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getUserManualCategory: {
+      summary: 'Get user manual category',
+      method: 'GET',
+      path: '/categories/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualCategorySchema,
+      }),
+      query: z.object({}).merge(userManualCategoriesIncludeQuery),
+      responses: {
+        200: IUserManualCategory,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'user-manuals',
+  },
+);