@dalmore/api-contracts 1.0.0

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

@@ -0,0 +1,116 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ComplianceReview,
+  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: z
+        .object({ status: z.nativeEnum(ComplianceReview) })
+        .merge(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',
+  },
+);

package/contracts/compliance/data-rooms/index.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { initContract } from '@ts-rest/core';
+import {
+  ComplianceReview,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  dataRoomIdSchema,
+  DataRoomApprovalsZod,
+  DataRoomsFilters,
+  DataRoomsIncludeQuery,
+  IPaginatedDataRooms,
+  DataRoomZod,
+  DataRoomStructureZod,
+  DataRoomFilesSummaryFilterZod,
+  IPaginatedDataRoomFilesSummaryZod,
+  DataRoomPasswordQueryZod,
+} from '../../../common/types/data-room.types';
+
+const c = initContract();
+
+export const dataRoomsContract = c.router(
+  {
+    getDataRooms: {
+      summary: 'Get paginated data-rooms',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(DataRoomsFilters).merge(
+        DataRoomsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedDataRooms,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getDataRoom: {
+      summary: 'Get data-room by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: DataRoomsIncludeQuery.merge(DataRoomPasswordQueryZod),
+      pathParams: z.object({ id: dataRoomIdSchema }),
+      responses: {
+        200: DataRoomZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getDataRoomApprovals: {
+      summary: 'Get data-room approvals',
+      method: 'GET',
+      path: '/approvals',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({ status: z.nativeEnum(ComplianceReview) }),
+      responses: {
+        200: z.array(DataRoomApprovalsZod),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getDataRoomStructure: {
+      summary:
+        'Get data room structure by id - shows the proper tree structure of the data room',
+      method: 'GET',
+      path: '/:id/structure',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: dataRoomIdSchema }),
+      query: DataRoomPasswordQueryZod,
+      responses: {
+        200: DataRoomStructureZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getDataRoomFilesSummary: {
+      summary: 'Get dataroom files based on compliancereview and structure',
+      method: 'GET',
+      path: '/files/summary',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(DataRoomFilesSummaryFilterZod),
+      responses: {
+        200: IPaginatedDataRoomFilesSummaryZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'data-rooms',
+  },
+);

package/contracts/compliance/default-theme-configs/index.ts

@@ -0,0 +1,95 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  defaultThemeConfigIdSchema,
+  ForbiddenError,
+  GetDefaultThemeConfig,
+  IDefaultThemeConfig,
+  InternalError,
+  IPaginatedDefaultThemeConfigsZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  PatchDefaultThemeConfigZod,
+  PostDefaultThemeConfigZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const defaultThemeConfigsContract = c.router(
+  {
+    getDefaultThemeConfigs: {
+      summary: '[ADMIN] Get Default Theme Configs',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod,
+      responses: {
+        200: IPaginatedDefaultThemeConfigsZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getDefaultThemeConfig: {
+      summary: '[ADMIN] Get default theme config by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: defaultThemeConfigIdSchema,
+      }),
+      responses: {
+        200: GetDefaultThemeConfig,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postDefaultThemeConfig: {
+      summary: '[ADMIN] Create default theme config',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostDefaultThemeConfigZod,
+      responses: {
+        201: IDefaultThemeConfig,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    patchDefaultThemeConfig: {
+      summary: '[ADMIN] Update default theme config',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: defaultThemeConfigIdSchema,
+      }),
+      body: PatchDefaultThemeConfigZod,
+      responses: {
+        200: IDefaultThemeConfig,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'default-theme-configs',
+  },
+);

package/contracts/compliance/disbursement/index.ts

@@ -0,0 +1,165 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  CompliancePostDisbursementZod,
+  DisbursementBalanceZod,
+  DisbursementFiltersZod,
+  disbursementIdSchema,
+  DisbursementMissingConfigZod,
+  DisbursementSigningLinkZod,
+  DisbursementsIncludeQuery,
+  DisbursementsMissingConfigQuery,
+  DisbursementSummaryZod,
+  DisbursementZod,
+  IPaginatedDisbursement,
+  PostDisbursementBalanceZod,
+  PostDisbursementSummaryZod,
+} from '../../../common/types/disbursements.types';
+import { PostComplianceReviewDisbursementZod } from '../../../common/types/disbursement-review.types';
+
+const c = initContract();
+
+export const disbursementContract = c.router(
+  {
+    postDisbursement: {
+      summary: 'Create a disbursement',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: CompliancePostDisbursementZod,
+      responses: {
+        201: DisbursementZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postDisbursementBalance: {
+      summary: 'Get a disbursement balance',
+      method: 'POST',
+      path: '/balance',
+      metadata: {
+        auth: true,
+      },
+      body: PostDisbursementBalanceZod,
+      responses: {
+        201: DisbursementBalanceZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postDisbursementSummary: {
+      summary: 'Get a disbursement summary',
+      method: 'POST',
+      path: '/summary',
+      metadata: {
+        auth: true,
+      },
+      body: PostDisbursementSummaryZod,
+      responses: {
+        201: DisbursementSummaryZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getDisbursements: {
+      summary: 'Get disbursements',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(DisbursementFiltersZod).merge(
+        DisbursementsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedDisbursement,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getDisbursementsMissingConfig: {
+      summary: 'Get missing configuration for disbursements',
+      method: 'GET',
+      path: '/config',
+      metadata: {
+        auth: true,
+      },
+      query: DisbursementsMissingConfigQuery,
+      responses: {
+        200: DisbursementMissingConfigZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getDisbursement: {
+      summary: 'Get disbursement by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(DisbursementsIncludeQuery),
+      pathParams: z.object({ id: disbursementIdSchema }),
+      responses: {
+        200: DisbursementZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    reviewDisbursements: {
+      summary: 'Review Disbursements',
+      method: 'POST',
+      path: '/review',
+      metadata: {
+        auth: true,
+      },
+      body: PostComplianceReviewDisbursementZod,
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getDisbursementEmbeddedSigningLink: {
+      summary: 'Review Disbursements',
+      method: 'GET',
+      path: '/:id/signing-link',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: disbursementIdSchema }),
+      responses: {
+        200: DisbursementSigningLinkZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'disbursements',
+  },
+);

package/contracts/compliance/disbursement-approval-users/index.ts

@@ -0,0 +1,84 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  PaginationOptionsZod,
+  BadRequestError,
+  accountIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  DisbursementApprovalUserFiltersZod,
+  disbursementApprovalUserIdSchema,
+  DisbursementApprovalUsersIncludeQuery,
+  DisbursementApprovalUserZod,
+  IPaginatedDisbursementApprovalUser,
+  PostComplianceDisbursementApprovalUser,
+} from '../../../common/types/disbursement-approval-user.types';
+
+const c = initContract();
+
+export const disbursementApprovalUsersContract = c.router(
+  {
+    getDisbursementApprovalUsers: {
+      summary: '[ADMIN] Get disbursement approval users',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(
+        DisbursementApprovalUserFiltersZod,
+      ).merge(DisbursementApprovalUsersIncludeQuery),
+      responses: {
+        200: IPaginatedDisbursementApprovalUser,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postDisbursementApprovalUser: {
+      summary: '[ADMIN] Create disbursement approval user',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostComplianceDisbursementApprovalUser,
+      responses: {
+        201: DisbursementApprovalUserZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+
+    deleteDisbursementApprovalUser: {
+      summary: '[ADMIN] Delete disbursement approval user',
+      method: 'DELETE',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: disbursementApprovalUserIdSchema,
+      }),
+      query: z.object({ accountId: accountIdSchema.optional() }),
+      responses: {
+        200: z.object({ success: z.boolean() }),
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'disbursement-approval-users',
+  },
+);

package/contracts/compliance/disbursement-transactions/index.ts

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