@dalmore/api-contracts 0.0.0-dev.2dc8e92

package/contracts/compliance/exchange-imports/index.ts

@@ -0,0 +1,137 @@
+import { initContract } from '@ts-rest/core';
+import {
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  BadRequestError,
+  ForbiddenError,
+  PaginationOptionsZod,
+} from '../../../common/types';
+import {} from '../../../common/types/escrow-account.types';
+import {
+  PostAdminExchangeImport,
+  ExchangeImport,
+  UpdateExchangeImport,
+  exchangeImportIdSchema,
+  PaginatedExchangeImports,
+  TriggerExchangeImport,
+} from '../../../common/types/exchange-provider.types';
+import { z } from 'zod';
+import {
+  ExchangeImportsFilter,
+  ExchangeImportsIncludeQuery,
+} from '../../../common/types/exchange-import.types';
+
+const c = initContract();
+
+export const exchangeImportsContract = c.router(
+  {
+    postExchangeImport: {
+      summary: '[ADMIN] Create an exchange import',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostAdminExchangeImport,
+      responses: {
+        201: ExchangeImport,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateExchangeImport: {
+      summary: '[ADMIN] Update an exchange import',
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: exchangeImportIdSchema }),
+      body: UpdateExchangeImport,
+      responses: {
+        200: ExchangeImport,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getExchangeImports: {
+      summary: '[ADMIN] Get exchange imports',
+      method: 'GET',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(ExchangeImportsFilter).merge(
+        ExchangeImportsIncludeQuery,
+      ),
+      responses: {
+        200: PaginatedExchangeImports,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getExchangeImport: {
+      summary: '[ADMIN] Get an exchange import',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: exchangeImportIdSchema }),
+      responses: {
+        200: ExchangeImport,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deleteExchangeImport: {
+      summary: '[ADMIN] Delete an exchange import',
+      method: 'DELETE',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: exchangeImportIdSchema }),
+      responses: {
+        200: ExchangeImport,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    triggerExchangeImport: {
+      summary: '[ADMIN] Trigger an exchange import',
+      method: 'POST',
+      path: '/:id/trigger',
+      metadata: {
+        auth: true,
+      },
+      body: TriggerExchangeImport,
+      pathParams: z.object({ id: exchangeImportIdSchema }),
+      responses: {
+        200: ExchangeImport,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'exchange-imports',
+  },
+);

package/contracts/compliance/files/index.ts

@@ -0,0 +1,267 @@
+import { initContract } from '@ts-rest/core';
+import {
+  accountIdSchema,
+  BadGateWayError,
+  BadRequestError,
+  ComplianceFilesIncludeQuery,
+  fileIdSchema,
+  FilePipeLineReviewSchemaZod,
+  FileZod,
+  ForbiddenError,
+  InternalError,
+  IPaginatedFile,
+  LinkFileZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  PatchFile,
+  PatchFileMetadata,
+  PostFileQueryParams,
+  ReprocessAllFilesZod,
+  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',
+            accountId: 'account_01j5tkg6k2fygr0x06fegt27aj',
+          },
+          headers: authHeader,
+          formData: { file: '@"/Users/local/Desktop/test.csv"' },
+        },
+      ),
+      method: 'POST',
+      path: '',
+      query: PostFileQueryParams.merge(
+        z.object({ accountId: accountIdSchema }),
+      ),
+      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(ComplianceFilesIncludeQuery),
+      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,
+      },
+    },
+    patchFileMetadata: {
+      summary: 'Patch file metadata',
+      method: 'PATCH',
+      path: '/:id/metadata',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: PatchFileMetadata,
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        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,
+      },
+    },
+    processFile: {
+      summary: 'Process a file',
+      method: 'POST',
+      path: '/:id/process',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    reprocessFile: {
+      summary: 'Reprocess a file',
+      method: 'POST',
+      path: '/:id/reprocess',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        200: z.object({ success: z.boolean() }),
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    reprocessAllFiles: {
+      summary: 'Reprocess all files',
+      method: 'POST',
+      path: '/reprocess/all',
+      metadata: {
+        auth: true,
+      },
+      body: z.object({}),
+      responses: {
+        201: ReprocessAllFilesZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    filePipeLineReview: {
+      summary: 'File pipe line review',
+      method: 'POST',
+      path: '/:id/pipeline-review',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: fileIdSchema,
+      }),
+      body: FilePipeLineReviewSchemaZod,
+      responses: {
+        200: z.object({ success: z.boolean() }),
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'files',
+  },
+);

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

@@ -0,0 +1,188 @@
+import { initContract } from '@ts-rest/core';
+import {
+  accountIdSchema,
+  BadGateWayError,
+  BadRequestError,
+  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',
+            accountId: 'account_01j5tkg6k2fygr0x06fegt27aj',
+          },
+          headers: authHeader,
+          formData: { file: '@"/Users/local/Desktop/test.csv"' },
+        },
+      ),
+      method: 'POST',
+      path: '',
+      query: PostFileQueryParams.merge(
+        z.object({ accountId: accountIdSchema }),
+      ),
+      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,
+      },
+    },
+    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/compliance/health/index.ts

@@ -0,0 +1,26 @@
+import { initContract } from '@ts-rest/core';
+import { InternalError } from '../../../common/types';
+import {
+  HealthCheckResponseSchema,
+  HealthErrorSchema,
+} from '../../../common/types/health.types';
+
+const c = initContract();
+
+export const healthContract = c.router(
+  {
+    getHealth: {
+      summary: 'Health Check',
+      method: 'GET',
+      path: '',
+      responses: {
+        200: HealthCheckResponseSchema,
+        500: InternalError,
+        503: HealthErrorSchema,
+      },
+    },
+  },
+  {
+    pathPrefix: 'health/',
+  },
+);