@dalmore/api-contracts 1.0.5 → 1.0.6

package/src/contracts/clients/aic/index.ts

@@ -0,0 +1,59 @@
+import { initContract } from '@ts-rest/core';
+import {
+  AicIncludeQuery,
+  AicZod,
+  AttachAicFileBodyZod,
+  BadRequestError,
+  ForbiddenError,
+  individualIdSchema,
+  InternalError,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+export const aicContract = c.router(
+  {
+    getAic: {
+      summary: 'Get AIC',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        individualId: individualIdSchema,
+      }),
+      query: AicIncludeQuery,
+      responses: {
+        200: AicZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    attachAicFile: {
+      summary: 'Attach AIC File',
+      method: 'PUT',
+      path: '/file',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        individualId: individualIdSchema,
+      }),
+      body: AttachAicFileBodyZod,
+      responses: {
+        200: AicZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'individual/:individualId/aic',
+  },
+);

package/src/contracts/clients/api-key-logs/index.ts

@@ -0,0 +1,53 @@
+import { initContract } from '@ts-rest/core';
+
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  IPaginatedApiLogs,
+  ApiLogsTotalsZod,
+  ApiLogsFiltersZod,
+  ApiLogsTotalsFiltersZod,
+} from '../../../common/types/api-key-logs.types';
+
+const c = initContract();
+
+export const clientApiKeyLogsContract = c.router(
+  {
+    // GET /clients/api-key-logs
+    getApiKeyLogs: {
+      summary: 'Get API key logs',
+      method: 'GET',
+      path: '',
+      metadata: { auth: true },
+      query: PaginationOptionsZod.merge(ApiLogsFiltersZod),
+      responses: {
+        200: IPaginatedApiLogs,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    // GET /clients/api-key-logs/totals
+    getApiKeyLogsTotals: {
+      summary: 'Get totals of API key logs',
+      method: 'GET',
+      path: '/totals',
+      metadata: { auth: true },
+      query: ApiLogsTotalsFiltersZod,
+      responses: {
+        200: ApiLogsTotalsZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  { pathPrefix: 'api-key-logs' },
+);

package/src/contracts/clients/api-keys/index.ts

@@ -0,0 +1,73 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  UnauthorizedError,
+  InternalError,
+  ApiKeyZod,
+  IPaginatedApiKeys,
+  PaginationOptionsZod,
+  BadRequestError,
+  apiKeyIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const apiKeysContract = c.router(
+  {
+    getApiKeys: {
+      summary: 'Get API Keys',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod,
+      responses: {
+        200: IPaginatedApiKeys,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getApiKey: {
+      summary: 'Get API Key',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: apiKeyIdSchema,
+      }),
+      responses: {
+        200: ApiKeyZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    deactivateApiKey: {
+      summary: 'Deactivate API Key by id',
+      method: 'PATCH',
+      path: '/:id/deactivate',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: apiKeyIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        202: ApiKeyZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'api-keys',
+  },
+);

package/src/contracts/clients/assets/index.ts

@@ -0,0 +1,102 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ConflictError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  AssetFiltersZod,
+  assetIdSchema,
+  AssetsIncludeQuery,
+  IAsset,
+  IPaginatedAsset,
+  PostAsset,
+  PutAsset,
+} from '../../../common/types/asset.types';
+
+const c = initContract();
+
+export const assetsContract = c.router(
+  {
+    getAssets: {
+      summary: 'Get assets',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(AssetsIncludeQuery).merge(AssetFiltersZod),
+      responses: {
+        200: IPaginatedAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getAsset: {
+      summary: 'Get asset by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(AssetsIncludeQuery),
+      pathParams: z.object({
+        id: assetIdSchema,
+      }),
+      responses: {
+        200: IAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    postAssets: {
+      summary: 'Create an asset',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostAsset,
+      responses: {
+        201: IAsset,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        409: ConflictError,
+        500: InternalError,
+      },
+    },
+    updateAsset: {
+      summary: 'Update asset',
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: assetIdSchema,
+      }),
+      body: PutAsset,
+      responses: {
+        201: IAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+
+  {
+    pathPrefix: 'assets',
+  },
+);

package/src/contracts/clients/auth/index.ts

@@ -0,0 +1,50 @@
+import { initContract } from '@ts-rest/core';
+import {
+  AccessTokenResponse,
+  BadRequestError,
+  ClientAuthSuccessResponse,
+  InternalError,
+  IRegisterClientIssuerBodyZod,
+  RegisterBodyInvestors,
+  UnauthorizedError,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const authContract = c.router(
+  {
+    registerInvestor: {
+      summary: 'Register investor with email (API Key Auth)',
+      method: 'POST',
+      path: 'register/investor',
+      metadata: {
+        auth: true,
+      },
+      body: RegisterBodyInvestors,
+      responses: {
+        201: ClientAuthSuccessResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    registerIssuer: {
+      summary: 'Register issuer with email (API Key Auth)',
+      method: 'POST',
+      path: 'register/issuer',
+      metadata: {
+        auth: true,
+      },
+      body: IRegisterClientIssuerBodyZod,
+      responses: {
+        201: AccessTokenResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'auth/',
+  },
+);

package/src/contracts/clients/files/index.ts

@@ -0,0 +1,166 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadGateWayError,
+  BadRequestError,
+  ClientPostFileQueryParams,
+  fileIdSchema,
+  FilesIncludeQuery,
+  FileZod,
+  InternalError,
+  IPaginatedFile,
+  LinkFileZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  PatchFile,
+  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. CLIENT portal only supports uploads to INDIVIDUALS.',
+        'POST',
+        '/files',
+        {
+          query: {
+            name: 'test',
+            category: 'application',
+            targetId: 'individual_01j5tkg6k2fygr0x06fegt27aj',
+          },
+          headers: authHeader,
+          formData: { file: '@"/Users/local/Desktop/test.csv"' },
+        },
+      ),
+      method: 'POST',
+      path: '',
+      query: ClientPostFileQueryParams,
+      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),
+      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/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/src/contracts/clients/index.ts

@@ -0,0 +1,44 @@
+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 { 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';
+
+const c = initContract();
+
+// API KEY AUTH
+export const clientsContract = c.router(
+  {
+    accounts: accountsContract,
+    aic: aicContract,
+    auth: authContract,
+    apiKeys: apiKeysContract,
+    apiKeyLogs: clientApiKeyLogsContract,
+    assets: assetsContract,
+    files: filesContract,
+    filesPublic: filesPublicContract,
+    individuals: individualsContract,
+    investorAccounts: investorAccountsContract,
+    issuers: issuersContract,
+    legalEntities: legalEntityContract,
+    offerings: offeringsContract,
+    secureRequests: secureRequestContract,
+    sites: sitesContract,
+    trades: tradesContract,
+  },
+  {
+    pathPrefix: '/clients/api/v1/',
+  },
+);