@dalmore/api-contracts 1.0.0

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

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  dataRoomIdSchema,
+  DataRoomPasswordQueryZod,
+  DataRoomsIncludeQuery,
+  DataRoomStructureZod,
+  DataRoomZod,
+  InvestorDataRoomsFilters,
+  IPaginatedDataRooms,
+  PublicDataRoomFiltersZod,
+} 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(InvestorDataRoomsFilters).merge(
+        DataRoomsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedDataRooms,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getPublicDataRooms: {
+      summary: 'Get public data rooms',
+      method: 'GET',
+      path: '/public',
+      query: PublicDataRoomFiltersZod,
+      responses: {
+        200: IPaginatedDataRooms,
+        400: BadRequestError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        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,
+      },
+    },
+  },
+  {
+    pathPrefix: 'data-rooms',
+  },
+);

package/contracts/investors/files/index.ts

@@ -0,0 +1,167 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadGateWayError,
+  BadRequestError,
+  FileFilters,
+  fileIdSchema,
+  FilesIncludeQuery,
+  FileZod,
+  InternalError,
+  IPaginatedFile,
+  LinkFileZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  PatchFile,
+  PostFileQueryParams,
+  UnauthorizedError,
+  UnprocessableError,
+} from '../../../common/types';
+import { z } from 'zod';
+import { authHeader, generateApiDescription } from '../../../common/helpers';
+
+const c = initContract();
+
+export const filesContract = c.router(
+  {
+    postFile: {
+      summary: 'Upload a file',
+      description: generateApiDescription(
+        'Upload a file to the system.',
+        'POST',
+        '/files',
+        {
+          query: {
+            name: 'test',
+            category: 'application',
+            targetId: 'trade_01j5tkg6k2fygr0x06fegt27aj',
+          },
+          headers: authHeader,
+          formData: { file: '@"/Users/local/Desktop/test.csv"' },
+        },
+      ),
+      method: 'POST',
+      path: '',
+      query: PostFileQueryParams,
+      contentType: 'multipart/form-data',
+      body: c.type<{ file: File }>(),
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: FileZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        422: UnprocessableError,
+        500: InternalError,
+        502: BadGateWayError,
+      },
+    },
+    linkFile: {
+      summary: 'Links a file to a new resource',
+      method: 'POST',
+      path: '/:id/link',
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: LinkFileZod,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: FileZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        422: UnprocessableError,
+        500: InternalError,
+        502: BadGateWayError,
+      },
+    },
+    unlinkFile: {
+      summary: 'Unlinks a file to the parent resource',
+      method: 'POST',
+      path: '/:id/unlink',
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: z.object({}),
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        202: FileZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        422: UnprocessableError,
+        500: InternalError,
+        502: BadGateWayError,
+      },
+    },
+    getFiles: {
+      summary: 'Get files',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(FilesIncludeQuery).merge(FileFilters),
+      responses: {
+        200: IPaginatedFile,
+        401: UnauthorizedError,
+      },
+    },
+    getFile: {
+      summary: 'Get file by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      responses: {
+        200: FileZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    patchFile: {
+      summary: 'Update file by id',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: PatchFile,
+      responses: {
+        201: FileZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    previewFile: {
+      summary: 'Preview (stream) a file by id',
+      method: 'GET',
+      path: '/preview/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      responses: {
+        200: z.unknown(),
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'files',
+  },
+);

package/contracts/investors/files-public/index.ts

@@ -0,0 +1,185 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadGateWayError,
+  BadRequestError,
+  FileFilters,
+  fileIdSchema,
+  FilesIncludeQuery,
+  FileZod,
+  ForbiddenError,
+  InternalError,
+  IPaginatedFile,
+  LinkFileZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  PatchFile,
+  PostFileQueryParams,
+  reviewFiles,
+  UnauthorizedError,
+  UnprocessableError,
+} from '../../../common/types';
+import { z } from 'zod';
+import { authHeader, generateApiDescription } from '../../../common/helpers';
+
+const c = initContract();
+
+export const filesPublicContract = c.router(
+  {
+    postFilePublic: {
+      summary: 'Upload a public file',
+      description: generateApiDescription(
+        'Upload a public file to the system.',
+        'POST',
+        '/files-public',
+        {
+          query: {
+            name: 'test',
+            category: 'application',
+            targetId: 'trade_01j5tkg6k2fygr0x06fegt27aj',
+          },
+          headers: authHeader,
+          formData: { file: '@"/Users/local/Desktop/test.csv"' },
+        },
+      ),
+      method: 'POST',
+      path: '',
+      query: PostFileQueryParams,
+      contentType: 'multipart/form-data',
+      body: c.type<{ file: File }>(),
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: FileZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        422: UnprocessableError,
+        500: InternalError,
+        502: BadGateWayError,
+      },
+    },
+    linkFilePublic: {
+      summary: 'Links a public file to a new resource',
+      method: 'POST',
+      path: '/:id/link',
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: LinkFileZod,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: FileZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        422: UnprocessableError,
+        500: InternalError,
+        502: BadGateWayError,
+      },
+    },
+    unlinkFilePublic: {
+      summary: 'Unlinks a public file to the parent resource',
+      method: 'POST',
+      path: '/:id/unlink',
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: z.object({}),
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        202: FileZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        422: UnprocessableError,
+        500: InternalError,
+        502: BadGateWayError,
+      },
+    },
+    getFilesPublic: {
+      summary: 'Get public files',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(FilesIncludeQuery).merge(FileFilters),
+      responses: {
+        200: IPaginatedFile,
+        401: UnauthorizedError,
+      },
+    },
+    getFilePublic: {
+      summary: 'Get public file by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      responses: {
+        200: FileZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    patchFilePublic: {
+      summary: 'Update public file by id',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: PatchFile,
+      responses: {
+        201: FileZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    previewFilePublic: {
+      summary: 'Preview (stream) a public file by id',
+      method: 'GET',
+      path: '/preview/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      responses: {
+        200: z.unknown(),
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    reviewPublicFiles: {
+      summary: 'Review public files',
+      method: 'POST',
+      path: '/review',
+      metadata: {
+        auth: true,
+      },
+      body: reviewFiles,
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'files-public',
+  },
+);

package/contracts/investors/index.ts

@@ -0,0 +1,72 @@
+import { initContract } from '@ts-rest/core';
+import { individualsContract } from './individuals';
+import { legalEntityContract } from './legal-entities';
+import { authContract } from './auth';
+import { investorAccountsContract } from './investor-accounts';
+import { offeringsContract } from './offerings';
+import { usersContract } from './users';
+import { sitesContract } from './sites';
+import { paymentMethodsContract } from './payment-methods';
+import { tradesContract } from './trades';
+import { tradeLineItemsContract } from './trade-line-items';
+import { assetsContract } from './assets';
+import { issuersContract } from './issuers';
+import { filesContract } from './files';
+import { cartContract } from './cart';
+import { pagesContract } from './pages';
+import { portfoliosContract } from './portfolios';
+import { dataRecordsContract } from './data-records';
+import { dataRoomsContract } from './data-rooms';
+import { filesPublicContract } from './files-public';
+import { tasksContract } from './tasks';
+import { issuerPaymentMethodsContract } from './issuer-payment-methods';
+import { contactUsContract } from './contact-us';
+import { webhooksContract } from './webhooks';
+import { userManualsContract } from './user-manuals';
+import { investorNotesContract } from './notes';
+import { userSettingsContract } from './user-settings';
+import { trustedContactsContract } from './trusted-contacts';
+import { aicContract } from './aic';
+import { investorsTransactionsContract } from './transactions';
+import { accountContactsContract } from './account-contacts';
+import { bonusTiersContract } from './bonus-tiers';
+const c = initContract();
+
+export const investorsContract = c.router(
+  {
+    accountContacts: accountContactsContract,
+    assets: assetsContract,
+    auth: authContract,
+    aic: aicContract,
+    bonusTiers: bonusTiersContract,
+    cart: cartContract,
+    contactUs: contactUsContract,
+    dataRecords: dataRecordsContract,
+    dataRooms: dataRoomsContract,
+    files: filesContract,
+    filesPublic: filesPublicContract,
+    individuals: individualsContract,
+    investorAccounts: investorAccountsContract,
+    issuerPaymentMethods: issuerPaymentMethodsContract,
+    issuers: issuersContract,
+    legalEntities: legalEntityContract,
+    notes: investorNotesContract,
+    offerings: offeringsContract,
+    pages: pagesContract,
+    paymentMethods: paymentMethodsContract,
+    portfolios: portfoliosContract,
+    sites: sitesContract,
+    tasks: tasksContract,
+    tradeLineItems: tradeLineItemsContract,
+    trades: tradesContract,
+    transactions: investorsTransactionsContract,
+    trustedContacts: trustedContactsContract,
+    userManuals: userManualsContract,
+    users: usersContract,
+    userSettings: userSettingsContract,
+    webhooks: webhooksContract,
+  },
+  {
+    pathPrefix: '/investors/api/v1/',
+  },
+);

package/contracts/investors/individuals/index.ts

@@ -0,0 +1,99 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedIndividual,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  IndividualFiltersZod,
+  IndividualsIncludeQuery,
+  individualIdSchema,
+  PostIndividualBodySchema,
+  UpdateIndividualBodySchema,
+  IndividualResponseSchema,
+  IIndividualZod,
+  BadRequestError,
+  InternalError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const individualsContract = c.router(
+  {
+    createIndividual: {
+      summary: 'Create individual',
+      method: 'POST',
+      path: '/',
+      body: PostIndividualBodySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: IndividualResponseSchema,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateIndividual: {
+      summary: 'Update individual',
+      method: 'PATCH',
+      path: '/:id',
+      pathParams: z.object({
+        id: individualIdSchema,
+      }),
+      body: UpdateIndividualBodySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: IndividualResponseSchema,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getIndividual: {
+      summary: 'Get individual by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(IndividualsIncludeQuery),
+      pathParams: z.object({
+        id: individualIdSchema,
+      }),
+      responses: {
+        200: IIndividualZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getIndividuals: {
+      summary: 'Get individuals',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IndividualFiltersZod).merge(
+        IndividualsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedIndividual,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'individuals',
+  },
+);