@dalmore/api-contracts 0.0.0-dev.4ec8ae0 → 0.0.0-dev.56068a6

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

@@ -1,257 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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,
-  DisbursementPreviewZod,
-  DisbursementSummaryZod,
-  DisbursementZod,
-  GetDisbursementPreviewQueryZod,
-  EligibleOfferingsFiltersZod,
-  IPaginatedDisbursement,
-  IPaginatedEligibleOffering,
-  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,
-      },
-    },
-    getDisbursementPreview: {
-      summary: 'Get disbursement preview data for Step 2',
-      method: 'GET',
-      path: '/preview',
-      metadata: {
-        auth: true,
-      },
-      query: GetDisbursementPreviewQueryZod,
-      responses: {
-        200: DisbursementPreviewZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getEligibleOfferings: {
-      summary: 'Get eligible offerings for disbursement',
-      method: 'GET',
-      path: '/eligible-offerings',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(EligibleOfferingsFiltersZod),
-      responses: {
-        200: IPaginatedEligibleOffering,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'disbursements',
-  },
-);