@dalmore/api-contracts 1.0.3 → 1.0.5

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

@@ -1,96 +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,
-  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/src/contracts/investors/files/index.ts

@@ -1,167 +0,0 @@
-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/src/contracts/investors/files-public/index.ts

@@ -1,185 +0,0 @@
-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/src/contracts/investors/index.ts

@@ -1,72 +0,0 @@
-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/src/contracts/investors/individuals/index.ts

@@ -1,99 +0,0 @@
-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',
-  },
-);