@dalmore/api-contracts 0.0.0-dev.d8ef117 → 0.0.0-dev.e325dbb

package/contracts/issuers/email-themes/index.ts

@@ -1,242 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  ForbiddenError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  NotFoundError,
-  InternalError,
-} from '../../../common/types';
-import {} from '../../../common/types';
-import {
-  emailThemeIdSchema,
-  emailThemeSettingIdSchema,
-  EmailThemesList,
-  IEmailTheme,
-  IEmailThemeSetting,
-  PatchEmailThemeSetting,
-  IEmailThemeSettings,
-  PatchEmailThemeSettings,
-  PostEmailThemeZod,
-  ExportEmailThemeSettingsZod,
-  PatchEmailThemeNameZod,
-  ImportEmailThemeSettingsZod,
-  PreviewEmailThemeResponse,
-  SendPreviewEmailResponse,
-  SendPreviewEmailZod,
-  PreviewEmailThemeZod,
-  GenerateTemplatePreviewHtmlZod,
-} from '../../../common/types/email-theme.types';
-
-const c = initContract();
-
-export const emailThemesContract = c.router(
-  {
-    previewEmailTheme: {
-      summary: 'Preview an email theme',
-      method: 'GET',
-      path: '/preview',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: PreviewEmailThemeResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getEmailThemes: {
-      summary: 'Get the email themes for the current account',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: EmailThemesList,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-
-    getEmailTheme: {
-      summary: 'Get the email theme for the current account',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IEmailTheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    sendPreviewEmail: {
-      summary: 'Send a preview email',
-      method: 'POST',
-      path: '/send-preview-email',
-      metadata: {
-        auth: true,
-      },
-      body: SendPreviewEmailZod,
-      responses: {
-        201: SendPreviewEmailResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    sendTemplateEmail: {
-      summary: 'Send a template email',
-      method: 'POST',
-      path: '/send-template-email',
-      metadata: {
-        auth: true,
-      },
-      body: PreviewEmailThemeZod,
-      responses: {
-        201: SendPreviewEmailResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    generateTemplatePreviewHtml: {
-      summary: 'Generate HTML for a template email',
-      method: 'POST',
-      path: '/generate-template-preview-html',
-      metadata: {
-        auth: true,
-      },
-      body: GenerateTemplatePreviewHtmlZod,
-      responses: {
-        200: PreviewEmailThemeResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postEmailTheme: {
-      summary: 'Post a email theme',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostEmailThemeZod,
-      responses: {
-        201: IEmailTheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    patchEmailThemeSettings: {
-      summary: 'Patch email theme settings',
-      method: 'PATCH',
-      path: '/:id/email-theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      body: PatchEmailThemeSettings,
-      responses: {
-        201: IEmailThemeSettings,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    patchEmailThemeSetting: {
-      summary: 'Patch a email theme setting',
-      method: 'PATCH',
-      path: '/:id/email-theme/:emailThemeId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeSettingIdSchema,
-        emailThemeId: emailThemeIdSchema,
-      }),
-      body: PatchEmailThemeSetting,
-      responses: {
-        201: IEmailThemeSetting,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    importEmailThemeSettings: {
-      summary: 'Import email theme settings',
-      method: 'POST',
-      path: '/:id/import-theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      body: ImportEmailThemeSettingsZod,
-      responses: {
-        201: IEmailThemeSettings,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    exportEmailThemeSettings: {
-      summary: 'Export email theme settings',
-      method: 'GET',
-      path: '/:id/export-theme-settings',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      responses: {
-        200: ExportEmailThemeSettingsZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchEmailThemeName: {
-      summary: 'Patch the name of a email theme',
-      method: 'PATCH',
-      path: '/:id/name',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: emailThemeIdSchema,
-      }),
-      body: PatchEmailThemeNameZod,
-      responses: {
-        201: IEmailTheme,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'email-themes',
-  },
-);

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

@@ -1,81 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  PaginationOptionsZod,
-  BadRequestError,
-} from '../../../common/types';
-import {
-  escrowAccountIdSchema,
-  EscrowAccountsFilter,
-  EscrowAccountsIncludeQuery,
-  IEscrowAccount,
-  IPaginatedEscrowAccount,
-  PatchEscrowAccount,
-  PostEscrowAccount,
-} from '../../../common/types/escrow-account.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const escrowAccountsContract = c.router(
-  {
-    getEscrowAccounts: {
-      summary: 'Get escrow accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(EscrowAccountsFilter).merge(
-        EscrowAccountsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedEscrowAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postEscrowAccount: {
-      summary: 'Create an escrow account',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostEscrowAccount,
-      responses: {
-        201: IEscrowAccount,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchEscrowAccount: {
-      summary: 'Update escrow account',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: escrowAccountIdSchema }),
-      body: PatchEscrowAccount,
-      responses: {
-        201: IEscrowAccount,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'escrow-accounts',
-  },
-);

package/contracts/issuers/exchange-api-keys/index.ts

@@ -1,144 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-  BadRequestError,
-  ForbiddenError,
-  PaginationOptionsZod,
-} from '../../../common/types';
-import {
-  ExchangeApiKey,
-  exchangeApiKeyIdSchema,
-  PaginatedExchangeApiKeys,
-  PostExchangeApiKey,
-  UpdateExchangeApiKey,
-  ExchangeApiKeyStatusResponse,
-} from '../../../common/types/exchange-api-key.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const exchangeApiKeysContract = c.router(
-  {
-    postExchangeApiKey: {
-      summary: 'Create an exchange api key for an account',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: PostExchangeApiKey,
-      responses: {
-        201: ExchangeApiKey,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    updateExchangeApiKey: {
-      summary: 'Update an exchange api key for an account',
-      method: 'PUT',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: exchangeApiKeyIdSchema,
-      }),
-      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,
-      responses: {
-        200: PaginatedExchangeApiKeys,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getExchangeApiKey: {
-      summary: 'Get exchange api key for an account',
-      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: 'Deactivate an exchange api key for an account',
-      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: 'Delete an exchange api key for an account',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: exchangeApiKeyIdSchema }),
-      responses: {
-        200: ExchangeApiKey,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getExchangeApiKeyStatus: {
-      summary: 'Get exchange api key status',
-      method: 'GET',
-      path: '/:id/status',
-      metadata: {
-        auth: false,
-      },
-      pathParams: z.object({ id: exchangeApiKeyIdSchema }),
-      responses: {
-        200: ExchangeApiKeyStatusResponse,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-
-  {
-    pathPrefix: 'exchange-api-keys',
-  },
-);

package/contracts/issuers/files/index.ts

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