@dalmore/api-contracts 1.0.0

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

@@ -0,0 +1,257 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  dataRecordFileIdSchema,
+  DataRecordFileZod,
+  dataRecordIdSchema,
+  DataRecordsFilters,
+  DataRecordsIncludeQuery,
+  DataRecordStructureZod,
+  DataRecordZod,
+  DeleteDataRecordFile,
+  DeleteDataRecordFolder,
+  IPaginatedDataRecords,
+  MoveDataRecordFile,
+  MoveDataRecordFolder,
+  NavigationSummaryZod,
+  PatchDataRecordFile,
+  PatchDataRecordFolder,
+  PostDataRecordFile,
+  PostDataRecordFolder,
+  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,
+      },
+    },
+    postDataRecordFolder: {
+      summary: 'Create a data record folder',
+      method: 'POST',
+      path: '/folders',
+      metadata: {
+        auth: true,
+      },
+      body: PostDataRecordFolder,
+      responses: {
+        201: DataRecordZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchDataRecordFolder: {
+      summary: 'Update data record folder',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: dataRecordIdSchema }),
+      body: PatchDataRecordFolder,
+      responses: {
+        201: DataRecordZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deleteDataRecordFolder: {
+      summary:
+        'Deletes a folder and optionally(force=true) all its contents (subfolders and file associations)',
+      method: 'DELETE',
+      path: '/folders',
+      metadata: {
+        auth: true,
+      },
+      body: DeleteDataRecordFolder,
+      responses: {
+        204: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    moveDataRecordFolder: {
+      summary: 'Move a data record folder to a new parent',
+      method: 'POST',
+      path: '/folders/move',
+      metadata: {
+        auth: true,
+      },
+      body: MoveDataRecordFolder,
+      responses: {
+        201: DataRecordZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postDataRecordFile: {
+      summary: 'Create a data record file object to a folder',
+      method: 'POST',
+      path: '/files',
+      metadata: {
+        auth: true,
+      },
+      body: PostDataRecordFile,
+      responses: {
+        201: DataRecordFileZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchDataRecordFile: {
+      summary: 'Add a file to a folder via a data record file object',
+      method: 'PATCH',
+      path: '/files/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: dataRecordFileIdSchema }),
+      body: PatchDataRecordFile,
+      responses: {
+        201: DataRecordFileZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deleteDataRecordFile: {
+      summary:
+        'Delete a data record file from a folder - note that this does not delete the file itself',
+      method: 'DELETE',
+      path: '/files',
+      metadata: {
+        auth: true,
+      },
+      body: DeleteDataRecordFile,
+      responses: {
+        204: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    moveDataRecordFile: {
+      summary: 'Move a data record file from folder A to folder B',
+      method: 'POST',
+      path: '/files/move',
+      metadata: {
+        auth: true,
+      },
+      body: MoveDataRecordFile,
+      responses: {
+        201: DataRecordFileZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'data-records',
+  },
+);

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

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  dataRoomIdSchema,
+  DataRoomPasswordQueryZod,
+  DataRoomsFilters,
+  DataRoomsIncludeQuery,
+  DataRoomStructureZod,
+  DataRoomZod,
+  DeleteDataRoom,
+  IPaginatedDataRooms,
+  PatchDataRoomZod,
+  PostDataRoom,
+} from '../../../common/types/data-room.types';
+
+const c = initContract();
+
+export const dataRoomsContract = c.router(
+  {
+    getDataRooms: {
+      summary:
+        'Get Data Rooms - returns flat data room objects. See getDataRoomStructure for tree structure',
+      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 - returns a flat data room object. See getDataRoomStructure for tree structure',
+      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,
+      },
+    },
+    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,
+      },
+    },
+    postDataRoom: {
+      summary: 'Create a data room',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostDataRoom,
+      responses: {
+        201: DataRoomZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    patchDataRoom: {
+      summary: 'Update data room',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: dataRoomIdSchema }),
+      body: PatchDataRoomZod,
+      responses: {
+        201: DataRoomZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deleteDataRoom: {
+      summary:
+        'Deletes a data room and optionally (force=true) all its contents (subfolders and file associations)',
+      method: 'DELETE',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: DeleteDataRoom,
+      responses: {
+        204: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'data-rooms',
+  },
+);

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

@@ -0,0 +1,82 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  PaginationOptionsZod,
+  BadRequestError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  DisbursementApprovalUserFiltersZod,
+  disbursementApprovalUserIdSchema,
+  DisbursementApprovalUsersIncludeQuery,
+  DisbursementApprovalUserZod,
+  IPaginatedDisbursementApprovalUser,
+  PostDisbursementApprovalUser,
+} from '../../../common/types/disbursement-approval-user.types';
+
+const c = initContract();
+
+export const disbursementApprovalUsersContract = c.router(
+  {
+    getDisbursementApprovalUsers: {
+      summary: '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: 'Create disbursement approval user',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostDisbursementApprovalUser,
+      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,
+      }),
+      responses: {
+        200: z.object({ success: z.boolean() }),
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'disbursement-approval-users',
+  },
+);

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

@@ -0,0 +1,53 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  DisbursementTransactionZod,
+  PostDisbursementTransactionZod,
+} 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: PostDisbursementTransactionZod,
+      responses: {
+        201: DisbursementTransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getDisbursementTransactions: {
+      summary: 'Get disbursement transactions',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: DisbursementTransactionZod.array(),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'disbursement-transactions',
+  },
+);

package/contracts/issuers/disbursements/index.ts

@@ -0,0 +1,153 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+
+import { z } from 'zod';
+import { PostDisbursementReviewZod } from '../../../common/types/disbursement-review.types';
+import {
+  DisbursementBalanceZod,
+  DisbursementFiltersZod,
+  disbursementIdSchema,
+  DisbursementMissingConfigZod,
+  DisbursementsIncludeQuery,
+  DisbursementsMissingConfigQuery,
+  DisbursementSummaryZod,
+  DisbursementZod,
+  IPaginatedDisbursement,
+  PostDisbursementBalanceZod,
+  PostDisbursementSummaryZod,
+  PostDisbursementZod,
+} from '../../../common/types/disbursements.types';
+
+const c = initContract();
+
+export const disbursementsContract = c.router(
+  {
+    postDisbursement: {
+      summary: 'Create a disbursement',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostDisbursementZod,
+      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 mssing configurations for disbursements',
+      method: 'GET',
+      path: '/config',
+      metadata: {
+        auth: true,
+      },
+      query: DisbursementsMissingConfigQuery,
+      responses: {
+        200: DisbursementMissingConfigZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+
+    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,
+        500: InternalError,
+      },
+    },
+    reviewDisbursements: {
+      summary: 'Review Disbursements',
+      method: 'POST',
+      path: '/review',
+      metadata: {
+        auth: true,
+      },
+      body: PostDisbursementReviewZod,
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'disbursements',
+  },
+);