@dalmore/api-contracts 1.0.0

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

@@ -0,0 +1,166 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadGateWayError,
+  BadRequestError,
+  fileIdSchema,
+  FilesIncludeQuery,
+  FileZod,
+  InternalError,
+  IPaginatedFile,
+  PostFileQueryParams,
+  LinkFileZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  PatchFile,
+  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 an issuer file - Issuer files are public',
+      description: generateApiDescription(
+        'Upload a file to the system.',
+        'POST',
+        '/files-public',
+        {
+          query: {
+            name: 'test',
+            category: 'application',
+            targetId: 'covered_person_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),
+      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,
+      },
+    },
+  },
+  {
+    pathPrefix: 'files-public',
+  },
+);

package/contracts/issuers/health/index.ts

@@ -0,0 +1,24 @@
+import { initContract } from '@ts-rest/core';
+import { InternalError } from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const healthContract = c.router(
+  {
+    getHealth: {
+      summary: 'Health Check',
+      method: 'GET',
+      path: '',
+      responses: {
+        201: z.object({
+          status: z.literal('ok'),
+        }),
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'health/',
+  },
+);

package/contracts/issuers/index.ts

@@ -0,0 +1,112 @@
+import { initContract } from '@ts-rest/core';
+import { accountsContract } from './accounts';
+import { accountContactsContract } from './account-contacts';
+import { accountIntegrationsContract } from './account-integrations';
+import { assetsContract } from './assets';
+import { healthContract } from './health';
+import { issuerContract } from './issuer';
+import { authContract } from './auth';
+import { issuersOfferingsContract } from './offerings';
+import { issuerInvitesContract } from './invites';
+import { issuerNotesContract } from './notes';
+import { issuerTradesContract } from './trades';
+import { investorAccountsContract } from './investor-accounts';
+import { issuerUsersContract } from './users';
+import { coveredPersonsContract } from './covered-persons';
+import { activitiesContract } from './activities';
+import { filesPublicContract } from './files-public';
+import { pagesContract } from './pages';
+import { loginHistoriesContract } from './login-histories';
+import { dataRoomsContract } from './data-rooms';
+import { dataRecordsContract } from './data-records';
+import { filesContract } from './files';
+import { issuerPaymentMethodsContract } from './issuer-payment-methods';
+import { issuerTasksContract } from './tasks';
+import { issuerTransactionsContract } from './transactions';
+import { dashboardContract } from './dashboard';
+import { siteSettingsContract } from './site-settings';
+import { sitesContract } from './sites';
+import { contactUsContract } from './contact-us';
+import { paymentMethodsContract } from './payment-methods';
+import { userManualsContract } from './user-manuals';
+import { issuerBankAccountsContract } from './issuer-bank-accounts';
+import { disbursementsContract } from './disbursements';
+import { escrowAccountsContract } from './escrow-accounts';
+import { disbursementApprovalUsersContract } from './disbursement-approval-users';
+import { disbursementTransactionsContract } from './disbursement-transactions';
+import { userSettingsContract } from './user-settings';
+import { siteLinksContract } from './site-links';
+import { emailThemesContract } from './email-themes';
+import { kycsContract } from './kyc';
+import { reviewContract } from './review';
+import { secondaryCustomersContract } from './secondary-customers';
+import { secondaryOrdersContract } from './secondary-orders';
+import { secondaryTradesContract } from './secondary-trades';
+import { portfoliosContract } from './portfolios';
+import { exchangeApiKeysContract } from './exchange-api-keys';
+import { issuerApiKeysContract } from './api-keys';
+import { issuerApiKeyLogsContract } from './api-key-logs';
+import { aicContract } from './aic';
+import { rejectionReasonsContract } from './rejection-reasons';
+import { secureRequestContract } from './secure-requests';
+import { bonusTiersContract } from './bonus-tiers';
+const c = initContract();
+
+export const issuersContract = c.router(
+  {
+    accounts: accountsContract,
+    accountContacts: accountContactsContract,
+    accountIntegrations: accountIntegrationsContract,
+    activities: activitiesContract,
+    aic: aicContract,
+    assets: assetsContract,
+    auth: authContract,
+    bonusTiers: bonusTiersContract,
+    contactUs: contactUsContract,
+    coveredPersons: coveredPersonsContract,
+    dashboard: dashboardContract,
+    dataRecords: dataRecordsContract,
+    dataRooms: dataRoomsContract,
+    disbursementApprovalUsers: disbursementApprovalUsersContract,
+    disbursements: disbursementsContract,
+    disbursementTransactions: disbursementTransactionsContract,
+    emailThemes: emailThemesContract,
+    escrowAccounts: escrowAccountsContract,
+    exchangeApiKeys: exchangeApiKeysContract,
+    apiKeys: issuerApiKeysContract,
+    apiKeyLogs: issuerApiKeyLogsContract,
+    files: filesContract,
+    filesPublic: filesPublicContract,
+    health: healthContract,
+    investorAccounts: investorAccountsContract,
+    invites: issuerInvitesContract,
+    issuerBankAccounts: issuerBankAccountsContract,
+    issuerPaymentMethods: issuerPaymentMethodsContract,
+    issuers: issuerContract,
+    kycs: kycsContract,
+    loginHistories: loginHistoriesContract,
+    notes: issuerNotesContract,
+    offerings: issuersOfferingsContract,
+    pages: pagesContract,
+    paymentMethods: paymentMethodsContract,
+    portfolios: portfoliosContract,
+    rejectionReasons: rejectionReasonsContract,
+    review: reviewContract,
+    secondaryCustomers: secondaryCustomersContract,
+    secondaryOrders: secondaryOrdersContract,
+    secondaryTrades: secondaryTradesContract,
+    secureRequests: secureRequestContract,
+    siteLinks: siteLinksContract,
+    sites: sitesContract,
+    siteSettings: siteSettingsContract,
+    tasks: issuerTasksContract,
+    trades: issuerTradesContract,
+    transactions: issuerTransactionsContract,
+    userManuals: userManualsContract,
+    users: issuerUsersContract,
+    userSettings: userSettingsContract,
+  },
+  {
+    pathPrefix: '/issuers/api/v1/',
+  },
+);

package/contracts/issuers/investor-accounts/index.ts

@@ -0,0 +1,126 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  IIndividualZod,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  InvestorAccountsIncludeQuery,
+  investorAccountIdSchema,
+  IInvestorAccount,
+  IssuerInvestorAccountsFiltersZod,
+  IPaginatedInvestorAccounts,
+  InvestorAccountExportFilters,
+  GetInvestorAccountDetailsQuery,
+  RegisteredInvestorUserFiltersZod,
+  IPaginatedRegisteredInvestorUserZod,
+} from '../../../common/types/investor-account.types';
+
+const c = initContract();
+
+export const investorAccountsContract = c.router(
+  {
+    exportInvestorAccounts: {
+      summary: 'Export investor accounts to CSV',
+      method: 'GET',
+      path: '/export',
+      query: InvestorAccountExportFilters,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: z.unknown(),
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    exportRegisteredInvestorUsers: {
+      summary: 'Export registered investor users to CSV',
+      method: 'GET',
+      path: '/registered-users/export',
+      query: RegisteredInvestorUserFiltersZod,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: z.unknown(),
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    getInvestorAccounts: {
+      summary: 'Get investor accounts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IssuerInvestorAccountsFiltersZod),
+      responses: {
+        200: IPaginatedInvestorAccounts,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getRegisteredInvestorUsers: {
+      summary: 'Get registered investor users',
+      method: 'GET',
+      path: '/registered-users',
+      query: PaginationOptionsZod.merge(RegisteredInvestorUserFiltersZod),
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: IPaginatedRegisteredInvestorUserZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getInvestorAccount: {
+      summary: 'Get investor account by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(InvestorAccountsIncludeQuery),
+      pathParams: z.object({
+        id: investorAccountIdSchema,
+      }),
+      responses: {
+        200: IInvestorAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getInvestorAccountDetails: {
+      summary: 'Get investor account details',
+      method: 'GET',
+      path: '/:id/details',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: investorAccountIdSchema,
+      }),
+      query: GetInvestorAccountDetailsQuery,
+      responses: {
+        200: IIndividualZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'investor-accounts',
+  },
+);

package/contracts/issuers/invites/index.ts

@@ -0,0 +1,129 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  NotFoundError,
+  InternalError,
+  InviteWithUrl,
+  IPaginatedInvite,
+  PaginationOptionsZod,
+  PostIssuerInviteZod,
+  IssuerInvitesFiltersZod,
+  UnauthorizedError,
+  IssuerVerifyInviteResponse,
+  IssuerInvitesDecisionResponse,
+  inviteIdSchema,
+  InvitesIncludeQuery,
+  PatchInviteRoleZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const issuerInvitesContract = c.router(
+  {
+    getInvites: {
+      summary: '[OWNER] Get invites',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IssuerInvitesFiltersZod).merge(
+        InvitesIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedInvite,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    verifyInvite: {
+      summary: 'Verify invite',
+      method: 'GET',
+      path: '/verify/:code',
+      pathParams: z.object({
+        code: z.string(),
+      }),
+      responses: {
+        200: IssuerVerifyInviteResponse,
+        400: BadRequestError,
+        404: NotFoundError,
+      },
+    },
+    postInvite: {
+      summary: '[OWNER] Invite user',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostIssuerInviteZod,
+      responses: {
+        201: InviteWithUrl,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    acceptInvite: {
+      summary: 'Accept invite',
+      method: 'PATCH',
+      path: '/accept/:id',
+      pathParams: z.object({
+        id: inviteIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        201: IssuerInvitesDecisionResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    rejectInvite: {
+      summary: 'Verify invite',
+      method: 'PATCH',
+      path: '/reject/:id',
+      body: z.object({}),
+      pathParams: z.object({
+        id: inviteIdSchema,
+      }),
+      responses: {
+        201: IssuerInvitesDecisionResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchInviteRole: {
+      summary: 'Patch invite role',
+      method: 'PATCH',
+      path: '/role/:id',
+      pathParams: z.object({
+        id: inviteIdSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PatchInviteRoleZod,
+      responses: {
+        201: InviteWithUrl,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'invites',
+  },
+);

package/contracts/issuers/issuer/index.ts

@@ -0,0 +1,94 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  GetIssuersZod,
+  IIssuer,
+  IPaginatedIssuer,
+  IssuersIncludeQuery,
+  issuerIdSchema,
+  PostIssuerZod,
+  PutIssuerZod,
+} from '../../../common/types/issuer.types';
+const c = initContract();
+
+export const issuerContract = c.router(
+  {
+    getIssuers: {
+      summary: 'Get Issuers',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(IssuersIncludeQuery).merge(GetIssuersZod),
+      responses: {
+        200: IPaginatedIssuer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    postIssuer: {
+      summary: 'Create an issuer',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostIssuerZod,
+      responses: {
+        201: IIssuer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getIssuer: {
+      summary: 'Get issuer by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(IssuersIncludeQuery),
+      pathParams: z.object({ id: issuerIdSchema }),
+      responses: {
+        200: IIssuer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateIssuer: {
+      summary: 'Update issuer',
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: issuerIdSchema,
+      }),
+      body: PutIssuerZod,
+      responses: {
+        201: IIssuer,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuers',
+  },
+);