@dalmore/api-contracts 1.0.0

package/contracts/compliance/assets/index.ts

@@ -0,0 +1,122 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ConflictError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  AssetFiltersZod,
+  assetIdSchema,
+  AssetsIncludeQuery,
+  AssetSummaryFiltersZod,
+  IAsset,
+  IPaginatedAsset,
+  CompliancePostAsset,
+  CompliancePutAsset,
+  AssetSortZod,
+} from '../../../common/types/asset.types';
+import { z } from 'zod';
+
+const c = initContract();
+export const assetsContract = c.router(
+  {
+    getAssetsSummary: {
+      summary: 'Get assets summary',
+      method: 'GET',
+      path: '/summary',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(AssetSummaryFiltersZod),
+      responses: {
+        200: IPaginatedAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAssets: {
+      summary: 'Get assets',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(AssetsIncludeQuery)
+        .merge(AssetFiltersZod)
+        .merge(AssetSortZod),
+      responses: {
+        200: IPaginatedAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAsset: {
+      summary: 'Get asset by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(AssetsIncludeQuery),
+      pathParams: z.object({
+        id: assetIdSchema,
+      }),
+      responses: {
+        200: IAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postAssets: {
+      summary: 'Create an asset',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: CompliancePostAsset,
+      responses: {
+        201: IAsset,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        409: ConflictError,
+        500: InternalError,
+      },
+    },
+    updateAsset: {
+      summary: 'Update asset',
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: assetIdSchema,
+      }),
+      body: CompliancePutAsset,
+      responses: {
+        201: IAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+
+  {
+    pathPrefix: 'assets',
+  },
+);

package/contracts/compliance/auth/index.ts

@@ -0,0 +1,134 @@
+import { initContract } from '@ts-rest/core';
+import {
+  AccessTokenResponse,
+  AdminForgotPasswordRequestZod,
+  BadRequestError,
+  IChangePasswordBodyZod,
+  InternalError,
+  IRegisterBodyZod,
+  LoginBody,
+  LoginBody2FA,
+  NotFoundError,
+  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: IRegisterBodyZod,
+      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: LoginBody,
+      responses: {
+        200: AccessTokenResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    forgotPassword: {
+      summary: 'Forgot password',
+      method: 'POST',
+      path: 'forgot-password',
+      body: z.object({
+        email: z.string().email(),
+      }),
+      responses: {
+        200: null,
+        400: BadRequestError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    adminForgotPassword: {
+      summary: '[ADMIN] Forgot password',
+      method: 'POST',
+      path: 'forgot-password/admin',
+      body: AdminForgotPasswordRequestZod,
+      responses: {
+        200: z.string(),
+        400: BadRequestError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    resetPasswordVerify: {
+      summary: 'Reset password verify',
+      method: 'POST',
+      path: 'reset-password/verify',
+      body: z.object({
+        email: z.string().email(),
+        code: z.string(),
+      }),
+      responses: {
+        200: z.object({
+          valid: z.boolean(),
+        }),
+        400: BadRequestError,
+      },
+    },
+    resetPassword: {
+      summary: 'Reset password',
+      method: 'POST',
+      path: 'reset-password',
+      body: z.object({
+        email: z.string().email(),
+        code: z.string(),
+        password: z.string().min(6),
+      }),
+      responses: {
+        200: null,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    changePassword: {
+      summary: 'Change password',
+      method: 'POST',
+      path: 'change-password',
+      body: IChangePasswordBodyZod,
+      responses: {
+        201: null,
+        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/compliance/batch-jobs/index.ts

@@ -0,0 +1,62 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  InternalError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  BatchJobFiltersZod,
+  batchJobIdSchema,
+  BatchJobsIncludeQuery,
+  BatchJobZod,
+  IPaginatedBatchJob,
+} from '../../../common/types/batch-jobs.types';
+
+const c = initContract();
+
+export const batchJobsContract = c.router(
+  {
+    getBatchJob: {
+      summary: 'Get batch job by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(BatchJobsIncludeQuery),
+      pathParams: z.object({
+        id: batchJobIdSchema,
+      }),
+      responses: {
+        200: BatchJobZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getBatchJobs: {
+      summary: 'Get batch jobs',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(BatchJobFiltersZod).merge(
+        BatchJobsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedBatchJob,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'batch-jobs',
+  },
+);

package/contracts/compliance/checklist/index.ts

@@ -0,0 +1,87 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  ChecklistFiltersZodSchema,
+  ChecklistIncludeQuerySchema,
+  ChecklistParamsZodSchema,
+  IPaginatedChecklistSchema,
+  PatchChecklistSchema,
+  PostChecklistSchema,
+  ResponseChecklistZodSchema,
+} from '../../../common/types/checklist.types';
+
+const c = initContract();
+
+export const checkListContract = c.router(
+  {
+    getChecklist: {
+      summary: 'Get checklist by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: ChecklistParamsZodSchema,
+      query: ChecklistIncludeQuerySchema,
+      responses: {
+        200: ResponseChecklistZodSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getChecklists: {
+      summary: 'Query checklist by name or type',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(ChecklistFiltersZodSchema).merge(
+        ChecklistIncludeQuerySchema,
+      ),
+      responses: {
+        200: IPaginatedChecklistSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    createChecklist: {
+      summary: 'Create checklist ',
+      method: 'POST',
+      path: '',
+      body: PostChecklistSchema,
+      responses: {
+        201: ResponseChecklistZodSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateChecklist: {
+      summary: 'Update checklist ',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      body: PatchChecklistSchema,
+      pathParams: ChecklistParamsZodSchema,
+      responses: {
+        201: ResponseChecklistZodSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'checklists',
+  },
+);

package/contracts/compliance/checklist-items/index.ts

@@ -0,0 +1,86 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  ChecklistItemsFiltersZodSchema,
+  IPaginatedChecklistItemSchema,
+  ParamsChecklistItemSchema,
+  PatchChecklistItemSchema,
+  PostChecklistItemSchema,
+  ResponseChecklistItemSchema,
+} from '../../../common/types/checklist-items.types';
+
+const c = initContract();
+
+export const checkListItemsContract = c.router(
+  {
+    createChecklistItem: {
+      summary: 'Create checklist Item ',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostChecklistItemSchema,
+      responses: {
+        201: ResponseChecklistItemSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateChecklistItem: {
+      summary: 'Update checklist item',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      body: PatchChecklistItemSchema,
+      pathParams: ParamsChecklistItemSchema,
+      responses: {
+        201: ResponseChecklistItemSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    queryChecklistItem: {
+      summary: 'GET checklist items by Checklist id',
+      method: 'GET',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(ChecklistItemsFiltersZodSchema),
+      responses: {
+        200: IPaginatedChecklistItemSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getChecklistItem: {
+      summary: 'GET checklist items by Checklist id',
+      method: 'GET',
+      pathParams: ParamsChecklistItemSchema,
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: ResponseChecklistItemSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'checklist-items',
+  },
+);

package/contracts/compliance/covered-persons/index.ts

@@ -0,0 +1,97 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  PatchCoveredPersonsZod,
+  ReviewCoveredPersons,
+  UnauthorizedError,
+} from '../../../common/types';
+
+import {
+  coveredPersonIdSchema,
+  CoveredPersonsIncludeQuery,
+  GetCoveredPersonsZod,
+  ICoveredPerson,
+  IPaginatedCoveredPerson,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const coveredPersonsContract = c.router(
+  {
+    getCoveredPersons: {
+      summary: 'Get Covered Persons',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(CoveredPersonsIncludeQuery).merge(
+        GetCoveredPersonsZod,
+      ),
+      responses: {
+        200: IPaginatedCoveredPerson,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getCoveredPerson: {
+      summary: 'Get covered person by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(CoveredPersonsIncludeQuery),
+      pathParams: z.object({ id: coveredPersonIdSchema }),
+      responses: {
+        200: ICoveredPerson,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    patchCoveredPerson: {
+      summary: 'Update covered person',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: coveredPersonIdSchema }),
+      body: PatchCoveredPersonsZod,
+      responses: {
+        201: ICoveredPerson,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    reviewCoveredPersons: {
+      summary: 'Review CoveredPersons',
+      method: 'POST',
+      path: '/review',
+      metadata: {
+        auth: true,
+      },
+      body: ReviewCoveredPersons,
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'covered-persons',
+  },
+);

package/contracts/compliance/dashboard/index.ts

@@ -0,0 +1,111 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  IPaginatedTradeSummaryResponse,
+  InternalError,
+  BadRequestError,
+  TradeSummaryFilterZod,
+  IPaginatedOnboardingOfferingSummaryResponse,
+  OnboardingOfferingSummaryFilterZod,
+} from '../../../common/types';
+import { IPaginatedSecondaryTradeSummaryResponse } from '../../../common/types/secondary-trade.types';
+import {
+  DocumentSummaryFilterZod,
+  IPaginatedDocumentSummaryResponse,
+} from '../../../common/types/dashboard.types';
+import {
+  IPaginatedOnboardingAccountSummaryResponse,
+  OnboardingAccountSummaryFilterZod,
+} from '../../../common/types/account.types';
+
+const c = initContract();
+
+export const dashboardContract = c.router(
+  {
+    getPaginatedTradesSummary: {
+      summary: 'Get trades summary with pagination',
+      method: 'GET',
+      path: '/trades',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(TradeSummaryFilterZod),
+      responses: {
+        200: IPaginatedTradeSummaryResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getPaginatedSecondaryTradesSummary: {
+      summary: 'Get secondary trades summary with pagination',
+      method: 'GET',
+      path: '/secondary-trades',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod,
+      responses: {
+        200: IPaginatedSecondaryTradeSummaryResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getDocumentsSummary: {
+      summary: 'Get documents summary with pagination',
+      method: 'GET',
+      path: '/documents',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(DocumentSummaryFilterZod),
+      responses: {
+        200: IPaginatedDocumentSummaryResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getPaginatedOnBoardingAccountSummary: {
+      summary: 'Get onboarding account summary with pagination',
+      method: 'GET',
+      path: '/onboarding-accounts',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(OnboardingAccountSummaryFilterZod),
+      responses: {
+        200: IPaginatedOnboardingAccountSummaryResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getPaginatedOnBoardingOfferingSummary: {
+      summary: 'Get onboarding offering summary with pagination',
+      method: 'GET',
+      path: '/onboarding-offerings',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(OnboardingOfferingSummaryFilterZod),
+      responses: {
+        200: IPaginatedOnboardingOfferingSummaryResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'dashboard',
+  },
+);