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

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

@@ -0,0 +1,242 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,144 @@
+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

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