@dalmore/api-contracts 1.0.3 → 1.0.6

package/src/contracts/compliance/exchange-api-keys/index.ts

@@ -1,129 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  BadRequestError,
-  ForbiddenError,
-  PaginationOptionsZod,
-} from '../../../common/types';
-import {
-  ExchangeApiKey,
-  PaginatedExchangeApiKeys,
-  AdminPostExchangeApiKey,
-  exchangeApiKeyIdSchema,
-  UpdateExchangeApiKey,
-  ExchangeApiKeysIncludeQuery,
-  ExchangeApiKeysFilter,
-} from '../../../common/types/exchange-api-key.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const exchangeApiKeysContract = c.router(
-  {
-    postExchangeApiKey: {
-      summary: '[ADMIN] Create an exchange api key',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: AdminPostExchangeApiKey,
-      responses: {
-        201: ExchangeApiKey,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    updateExchangeApiKey: {
-      summary: '[ADMIN] Update an exchange api key',
-      method: 'PUT',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      body: UpdateExchangeApiKey,
-      responses: {
-        200: ExchangeApiKey,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getExchangeApiKeys: {
-      summary: '[ADMIN] Get exchange api keys',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ExchangeApiKeysFilter).merge(
-        ExchangeApiKeysIncludeQuery,
-      ),
-      responses: {
-        200: PaginatedExchangeApiKeys,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getExchangeApiKey: {
-      summary: '[ADMIN] Get exchange api key',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: exchangeApiKeyIdSchema }),
-      responses: {
-        200: ExchangeApiKey,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deactivateExchangeApiKey: {
-      summary: '[ADMIN] Deactivate an exchange api key',
-      method: 'GET',
-      path: '/:id/deactivate',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: exchangeApiKeyIdSchema }),
-      responses: {
-        200: ExchangeApiKey,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteExchangeApiKey: {
-      summary: '[ADMIN] Delete an exchange api key',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: exchangeApiKeyIdSchema }),
-      responses: {
-        200: ExchangeApiKey,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'exchange-api-keys',
-  },
-);

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

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

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

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