@dalmore/api-contracts 1.0.3 → 1.0.6

package/src/contracts/investors/portfolios/index.ts

@@ -1,53 +0,0 @@
-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/src/contracts/investors/sites/index.ts

@@ -1,96 +0,0 @@
-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/src/contracts/investors/tasks/index.ts

@@ -1,111 +0,0 @@
-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/src/contracts/investors/trade-line-items/index.ts

@@ -1,75 +0,0 @@
-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/src/contracts/investors/trades/index.ts

@@ -1,114 +0,0 @@
-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/src/contracts/investors/transactions/index.ts

@@ -1,37 +0,0 @@
-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/src/contracts/investors/trusted-contacts/index.ts

@@ -1,93 +0,0 @@
-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/src/contracts/investors/user-manuals/index.ts

@@ -1,62 +0,0 @@
-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',
-  },
-);