@dalmore/api-contracts 0.0.0-dev.0c67bc1

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

@@ -0,0 +1,166 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadGateWayError,
+  BadRequestError,
+  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 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),
+      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/clients/index.ts

@@ -0,0 +1,52 @@
+import { initContract } from '@ts-rest/core';
+import { accountsContract } from './accounts';
+import { apiKeysContract } from './api-keys';
+import { clientApiKeyLogsContract } from './api-key-logs';
+import { assetsContract } from './assets';
+import { cartContract } from './cart';
+import { filesContract } from './files';
+import { individualsContract } from './individuals';
+import { investorAccountsContract } from './investor-accounts';
+import { issuersContract } from './issuers';
+import { legalEntityContract } from './legal-entities';
+import { offeringsContract } from './offerings';
+import { tradesContract } from './trades';
+import { filesPublicContract } from './files-public';
+import { secureRequestContract } from './secure-requests';
+import { aicContract } from './aic';
+import { authContract } from './auth';
+import { sitesContract } from './sites';
+import { paymentMethodsContract } from './payment-methods';
+import { issuerPaymentMethodsContract } from './issuer-payment-methods';
+import { tradeLineItemsContract } from './trade-line-items';
+
+const c = initContract();
+
+// API KEY AUTH
+export const clientsContract = c.router(
+  {
+    accounts: accountsContract,
+    aic: aicContract,
+    auth: authContract,
+    apiKeys: apiKeysContract,
+    apiKeyLogs: clientApiKeyLogsContract,
+    assets: assetsContract,
+    cart: cartContract,
+    files: filesContract,
+    filesPublic: filesPublicContract,
+    individuals: individualsContract,
+    investorAccounts: investorAccountsContract,
+    issuerPaymentMethods: issuerPaymentMethodsContract,
+    issuers: issuersContract,
+    legalEntities: legalEntityContract,
+    offerings: offeringsContract,
+    paymentMethods: paymentMethodsContract,
+    secureRequests: secureRequestContract,
+    sites: sitesContract,
+    tradeLineItems: tradeLineItemsContract,
+    trades: tradesContract,
+  },
+  {
+    pathPrefix: '/clients/api/v1/',
+  },
+);

package/contracts/clients/individuals/index.ts

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedIndividual,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  IndividualFiltersZod,
+  IndividualsIncludeQuery,
+  individualIdSchema,
+  PostIndividualBodySchema,
+  UpdateIndividualBodySchema,
+  IndividualResponseSchema,
+  IIndividualZod,
+} 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,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateIndividual: {
+      summary: 'Update individual',
+      method: 'PATCH',
+      path: '/:id',
+      pathParams: z.object({
+        id: individualIdSchema,
+      }),
+      body: UpdateIndividualBodySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: IndividualResponseSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    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',
+  },
+);

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

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  IInvestorAccount,
+  investorAccountIdSchema,
+  InvestorAccountsFiltersZod,
+  InvestorAccountsIncludeQuery,
+  InvestorUpdatePathParamsSchema,
+  IPaginatedInvestorAccounts,
+  PostClientInvestorAccountBodySchema,
+  UpdateInvestorAccountBodySchema,
+} from '../../../common/types/investor-account.types';
+
+const c = initContract();
+
+export const investorAccountsContract = c.router(
+  {
+    createInvestorAccount: {
+      summary: 'Create investor account ',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostClientInvestorAccountBodySchema,
+      responses: {
+        201: IInvestorAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateInvestorAccount: {
+      summary: 'Update investor account ',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: InvestorUpdatePathParamsSchema,
+      body: UpdateInvestorAccountBodySchema,
+      responses: {
+        201: IInvestorAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    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,
+      },
+    },
+    getInvestorAccounts: {
+      summary: 'Get investor accounts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(InvestorAccountsIncludeQuery).merge(
+        InvestorAccountsFiltersZod,
+      ),
+      responses: {
+        200: IPaginatedInvestorAccounts,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'investor-accounts',
+  },
+);

package/contracts/clients/issuer-payment-methods/index.ts

@@ -0,0 +1,39 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  GetIssuerPaymentMethodZod,
+  IPaginatedIssuerPaymentMethod,
+  IssuerPaymentMethodsIncludeQuery,
+  PaginationOptionsZod,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerPaymentMethodsContract = c.router(
+  {
+    getIssuerPaymentMethods: {
+      summary: 'Get issuer payment methods',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod).merge(
+        IssuerPaymentMethodsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuer-payment-methods',
+  },
+);

package/contracts/clients/issuers/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 issuersContract = 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',
+  },
+);

package/contracts/clients/legal-entities/index.ts

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import {
+  PostLegalEntitySchema,
+  ResponseLegalEntitySchema,
+  UnauthorizedError,
+  ForbiddenError,
+  legalEntityIdSchema,
+  UpdateLegalEntitySchema,
+  LegalEntitiesIncludeQuery,
+  LegalEntityZod,
+  PaginationOptionsZod,
+  LegalEntityFiltersZod,
+  IPaginatedLegalEntity,
+  NotFoundError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const legalEntityContract = c.router(
+  {
+    createLegalEntity: {
+      summary: 'Create Legal Entity',
+      method: 'POST',
+      path: '/',
+      body: PostLegalEntitySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: ResponseLegalEntitySchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateLegalEntity: {
+      summary: 'Update Legal Entity',
+      method: 'PATCH',
+      path: '/:id',
+      pathParams: z.object({
+        id: legalEntityIdSchema,
+      }),
+      body: UpdateLegalEntitySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: ResponseLegalEntitySchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getLegalEntity: {
+      summary: 'Get legalEntity by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(LegalEntitiesIncludeQuery),
+      pathParams: z.object({
+        id: legalEntityIdSchema,
+      }),
+      responses: {
+        200: LegalEntityZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getLegalEntities: {
+      summary: 'Get legalEntities',
+      method: 'GET',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(LegalEntityFiltersZod).merge(
+        LegalEntitiesIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedLegalEntity,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'legal-entities',
+  },
+);