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

package/contracts/compliance/disbursement-transactions/index.ts

@@ -0,0 +1,37 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  CompliancePostDisbursementTransactionZod,
+  DisbursementTransactionZod,
+} from '../../../common/types/disbursement-transaction.types';
+
+const c = initContract();
+
+export const disbursementTransactionsContract = c.router(
+  {
+    postDisbursementTransaction: {
+      summary: 'Create a disbursement transaction',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: CompliancePostDisbursementTransactionZod,
+      responses: {
+        201: DisbursementTransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'disbursement-transactions',
+  },
+);

package/contracts/compliance/domain-filters/index.ts

@@ -0,0 +1,117 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  PaginationOptionsZod,
+  DomainFilterFiltersZod,
+  IPaginatedDomainFilter,
+  ForbiddenError,
+  UnauthorizedError,
+  NotFoundError,
+  domainFilterIdSchema,
+  DomainFilterZod,
+  PostDomainFilterZod,
+  ConflictError,
+  InternalError,
+  PatchDomainFilterZod,
+  DomainFilterDeleteResponseZod,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const domainFiltersContract = c.router(
+  {
+    getDomainFilters: {
+      summary: 'Get domain filters',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(DomainFilterFiltersZod),
+      responses: {
+        200: IPaginatedDomainFilter,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getDomainFilter: {
+      summary: 'Get domain filter by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: domainFilterIdSchema,
+      }),
+      responses: {
+        200: DomainFilterZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    createDomainFilter: {
+      summary: 'Create domain filter',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostDomainFilterZod,
+      responses: {
+        200: DomainFilterZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        409: ConflictError,
+        500: InternalError,
+      },
+    },
+    updateDomainFilter: {
+      summary: 'Update domain filter',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: domainFilterIdSchema,
+      }),
+      body: PatchDomainFilterZod,
+      responses: {
+        200: DomainFilterZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        409: ConflictError,
+        500: InternalError,
+      },
+    },
+    deleteDomainFilter: {
+      summary: 'Delete domain filter',
+      method: 'DELETE',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: domainFilterIdSchema,
+      }),
+      responses: {
+        200: DomainFilterDeleteResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'domain-filters',
+  },
+);

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

@@ -0,0 +1,284 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  InternalError,
+  UnauthorizedError,
+  accountIdSchema,
+  EmailThemesList,
+  EmailThemeFiltersZod,
+  IEmailTheme,
+  emailThemeIdSchema,
+  IEmailThemeSettings,
+  emailThemeSettingIdSchema,
+  IEmailThemeSetting,
+  ExportEmailThemeSettingsZod,
+  CompliancePostEmailThemeZod,
+  CompliancePatchEmailThemeSettings,
+  CompliancePatchEmailThemeSetting,
+  ComplianceImportEmailThemeSettingsZod,
+  CompliancePatchEmailThemeNameZod,
+  ComplianceSendPreviewEmailZod,
+  SendPreviewEmailResponse,
+  PreviewEmailThemeResponse,
+  PaginationOptionsZod,
+  GetEmailThemesAdminQuery,
+  CompliancePreviewEmailThemeZod,
+  ComplianceGenerateTemplatePreviewHtmlZod,
+  GetDefaultEmailThemesZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const emailThemesContract = c.router(
+  {
+    previewEmailTheme: {
+      summary: '[ADMIN] Preview an email theme',
+      method: 'GET',
+      path: '/preview',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        accountId: accountIdSchema,
+      }),
+      responses: {
+        200: PreviewEmailThemeResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getEmailThemesAdmin: {
+      summary: '[ADMIN] Get the email themes for the admin users',
+      method: 'GET',
+      path: '/admin',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(GetEmailThemesAdminQuery),
+      responses: {
+        200: EmailThemesList,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getDefaultEmailThemes: {
+      summary: '[ADMIN] Get the default email themes',
+      method: 'GET',
+      path: '/default-email-themes',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: GetDefaultEmailThemesZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getEmailThemes: {
+      summary: '[ADMIN] Get the themes for the specified account',
+      method: 'GET',
+      path: '/account/:accountId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        accountId: accountIdSchema,
+      }),
+      responses: {
+        200: EmailThemesList,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getEmailTheme: {
+      summary: '[ADMIN] Get the theme by id for the specified account',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: emailThemeIdSchema,
+      }),
+      query: z.object({}).merge(EmailThemeFiltersZod),
+      responses: {
+        200: IEmailTheme,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    sendPreviewEmail: {
+      summary: '[ADMIN] Send a preview email',
+      method: 'POST',
+      path: '/send-preview-email',
+      metadata: {
+        auth: true,
+      },
+      body: ComplianceSendPreviewEmailZod,
+      responses: {
+        201: SendPreviewEmailResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    sendTemplateEmail: {
+      summary: '[ADMIN] Send a template email',
+      method: 'POST',
+      path: '/send-template-email',
+      metadata: {
+        auth: true,
+      },
+      body: CompliancePreviewEmailThemeZod,
+      responses: {
+        201: SendPreviewEmailResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    generateTemplatePreviewHtml: {
+      summary: '[ADMIN] Generate HTML for a template email',
+      method: 'POST',
+      path: '/generate-template-preview-html',
+      metadata: {
+        auth: true,
+      },
+      body: ComplianceGenerateTemplatePreviewHtmlZod,
+      responses: {
+        200: PreviewEmailThemeResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postEmailTheme: {
+      summary: '[ADMIN] Post a email theme',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: CompliancePostEmailThemeZod,
+      responses: {
+        201: IEmailTheme,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+
+    patchEmailThemeSettings: {
+      summary: '[ADMIN] Patch email theme settings',
+      method: 'PATCH',
+      path: '/:id/email-theme-settings',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: emailThemeIdSchema,
+      }),
+      body: CompliancePatchEmailThemeSettings,
+      responses: {
+        201: IEmailThemeSettings,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchEmailThemeSetting: {
+      summary: '[ADMIN] Patch a email theme setting',
+      method: 'PATCH',
+      path: '/:id/email-theme/:emailThemeId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: emailThemeSettingIdSchema,
+        emailThemeId: emailThemeIdSchema,
+      }),
+      body: CompliancePatchEmailThemeSetting,
+      responses: {
+        201: IEmailThemeSetting,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    importEmailThemeSettings: {
+      summary: '[ADMIN] Import email theme settings',
+      method: 'POST',
+      path: '/:id/import-email-theme-settings',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: emailThemeIdSchema,
+      }),
+      body: ComplianceImportEmailThemeSettingsZod,
+      responses: {
+        201: IEmailThemeSettings,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+
+    exportEmailThemeSettings: {
+      summary: '[ADMIN] Export email theme settings',
+      method: 'GET',
+      path: '/:id/export-email-theme-settings',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: emailThemeIdSchema,
+      }),
+      responses: {
+        200: ExportEmailThemeSettingsZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchEmailThemeName: {
+      summary: '[ADMIN] Patch the name of a email theme',
+      method: 'PATCH',
+      path: '/:id/name',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: emailThemeIdSchema,
+      }),
+      body: CompliancePatchEmailThemeNameZod,
+      responses: {
+        201: IEmailTheme,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'email-themes',
+  },
+);

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

@@ -0,0 +1,85 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  PaginationOptionsZod,
+  BadRequestError,
+} from '../../../common/types';
+import {
+  CompliancePostEscrowAccount,
+  escrowAccountIdSchema,
+  EscrowAccountsFilter,
+  EscrowAccountsIncludeQuery,
+  IEscrowAccount,
+  IPaginatedEscrowAccount,
+  PatchEscrowAccount,
+} 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: CompliancePostEscrowAccount,
+      /* 
+        for compliance portal we'll be taking accountId from body as `ESCROW ACCOUNT` will 
+        be of some issuer.
+      */
+      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/compliance/exchange-api-keys/index.ts

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