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

package/contracts/compliance/account-contacts/index.ts

@@ -0,0 +1,82 @@
+import { initContract } from '@ts-rest/core';
+import {
+  accountIdSchema,
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  accountContactIdSchema,
+  CompliancePatchAccountContactZod,
+  IAccountContact,
+} from '../../../common/types/account-contact.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const accountContactsContract = c.router(
+  {
+    getAccountContacts: {
+      summary: '[ADMIN] Get Account Contacts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        accountId: accountIdSchema,
+      }),
+      responses: {
+        200: z.array(IAccountContact),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAccountContact: {
+      summary: '[ADMIN] Get account contact by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountContactIdSchema,
+      }),
+      query: z.object({
+        accountId: accountIdSchema,
+      }),
+      responses: {
+        200: IAccountContact,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    patchAccountContact: {
+      summary: '[ADMIN] Update account contact',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountContactIdSchema,
+      }),
+      body: CompliancePatchAccountContactZod,
+      responses: {
+        200: IAccountContact,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'account-contacts',
+  },
+);

package/contracts/compliance/account-managers/index.ts

@@ -0,0 +1,142 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  PreconditionFailedError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  AccountManagerDeleteQuery,
+  AccountManagerDeleteResponse,
+  accountManagerIdSchema,
+  AccountManagersIncludeQuery,
+  IAccountManagerZod,
+  IPaginatedAccountManager,
+  PatchAccountManagerZod,
+  PostAccountManagerZod,
+  SetDefaultAccountManagerForAllAccountsResponse,
+} from '../../../common/types/account-manager.types';
+
+const c = initContract();
+
+export const accountManagersContract = c.router(
+  {
+    getAccountManagers: {
+      summary: 'Get account managers',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(AccountManagersIncludeQuery),
+      responses: {
+        200: IPaginatedAccountManager,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAccountManager: {
+      summary: 'Get account manager by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(AccountManagersIncludeQuery),
+      pathParams: z.object({
+        id: accountManagerIdSchema,
+      }),
+      responses: {
+        200: IAccountManagerZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    setDefaultAccountManagerForAllAccounts: {
+      summary: '[ADMIN] Set default account manager for all accounts',
+      method: 'PATCH',
+      path: '/set-default-for-all-accounts',
+      metadata: {
+        auth: true,
+      },
+      body: z.object({}),
+      responses: {
+        200: SetDefaultAccountManagerForAllAccountsResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    patchAccountManager: {
+      summary: 'Update account manager by id',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountManagerIdSchema,
+      }),
+      body: PatchAccountManagerZod,
+      responses: {
+        201: IAccountManagerZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postAccountManager: {
+      summary: 'Create account manager',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostAccountManagerZod,
+      responses: {
+        201: IAccountManagerZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    deleteAccountManager: {
+      summary: 'Delete account manager by id',
+      method: 'DELETE',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountManagerIdSchema,
+      }),
+      query: AccountManagerDeleteQuery,
+      responses: {
+        201: AccountManagerDeleteResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        412: PreconditionFailedError,
+        500: InternalError,
+      },
+    },
+  },
+
+  {
+    pathPrefix: 'account-managers',
+  },
+);

package/contracts/compliance/accounts/index.ts

@@ -0,0 +1,187 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedAccount,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  AccountFiltersZod,
+  AccountsIncludeQuery,
+  AccountZod,
+  InternalError,
+  accountIdSchema,
+  CreateAccountZod,
+  AccountsSummaryFilterZod,
+  IPaginatedAccountsSummaryResponse,
+  UpdateAccountIssuersStatusZod,
+  UpdateAccountStatusReponse,
+  CompliancePatchAccountZod,
+  AccountSortZod,
+  BadRequestError,
+} from '../../../common/types';
+import { z } from 'zod';
+import { AccountDetailSummaryZod } from '../../../common/types/account-detail.types';
+import {
+  accountManagerIdSchema,
+  SetDefaultAccountManagerForAllAccountsResponse,
+} from '../../../common/types/account-manager.types';
+
+const c = initContract();
+
+export const accountsContract = c.router(
+  {
+    getPaginatedAccountsSummary: {
+      summary: 'Get accounts summary with pagination',
+      method: 'GET',
+      path: '/summary',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(AccountsSummaryFilterZod).merge(
+        AccountSortZod,
+      ),
+      responses: {
+        200: IPaginatedAccountsSummaryResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAccount: {
+      summary: 'Get account by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(AccountsIncludeQuery),
+      pathParams: z.object({
+        id: accountIdSchema,
+      }),
+      responses: {
+        200: AccountZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    // Admin
+    getAccountsAdmin: {
+      summary: '[ADMIN] Get accounts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(AccountFiltersZod).merge(
+          AccountsIncludeQuery,
+        ),
+      responses: {
+        200: IPaginatedAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    updateAccountAdmin: {
+      summary: '[ADMIN] Update account by id',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountIdSchema,
+      }),
+      body: CompliancePatchAccountZod,
+      responses: {
+        200: AccountZod,
+        404: NotFoundError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+
+    updateAccountStatusAdmin: {
+      summary: '[ADMIN] Update account status by id',
+      method: 'PATCH',
+      path: '/:id/status',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountIdSchema,
+      }),
+      body: UpdateAccountIssuersStatusZod,
+      responses: {
+        200: UpdateAccountStatusReponse,
+        404: NotFoundError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+
+    createAccount: {
+      summary: '[ADMIN] Create an account',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: CreateAccountZod,
+      responses: {
+        201: AccountZod,
+        404: NotFoundError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAccountDetailSummary: {
+      summary: 'Get account detail summary',
+      method: 'GET',
+      path: '/:id/detail-summary',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountIdSchema,
+      }),
+      responses: {
+        200: AccountDetailSummaryZod,
+        404: NotFoundError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    setAccountManagerForAccount: {
+      summary: 'Set account manager for account',
+      method: 'PATCH',
+      path: '/:id/set-account-manager-for-account',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountIdSchema,
+      }),
+      body: z.object({
+        accountManagerId: accountManagerIdSchema,
+      }),
+      responses: {
+        200: SetDefaultAccountManagerForAllAccountsResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'accounts',
+  },
+);

package/contracts/compliance/activities/index.ts

@@ -0,0 +1,55 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  ActivitiesFilters,
+  activityIdSchema,
+  ActivityZod,
+  IPaginatedActivity,
+} from '../../../../src/common/types/activity.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const activitiesContract = c.router(
+  {
+    getActivities: {
+      summary: 'Get activities',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(ActivitiesFilters),
+      responses: {
+        200: IPaginatedActivity,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getActivity: {
+      summary: 'Get activity by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: activityIdSchema,
+      }),
+      responses: {
+        200: ActivityZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'activities',
+  },
+);

package/contracts/compliance/aic/index.ts

@@ -0,0 +1,60 @@
+import { initContract } from '@ts-rest/core';
+import {
+  AicIncludeQuery,
+  AicZod,
+  BadRequestError,
+  ComplianceAicQueryZod,
+  ComplianceAttachAicFileBodyZod,
+  ForbiddenError,
+  individualIdSchema,
+  InternalError,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+export const aicContract = c.router(
+  {
+    getAic: {
+      summary: 'Get AIC',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        individualId: individualIdSchema,
+      }),
+      query: AicIncludeQuery.merge(ComplianceAicQueryZod),
+      responses: {
+        200: AicZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    attachAicFile: {
+      summary: 'Attach AIC File',
+      method: 'PUT',
+      path: '/file',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        individualId: individualIdSchema,
+      }),
+      body: ComplianceAttachAicFileBodyZod,
+      responses: {
+        200: AicZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'individual/:individualId/aic',
+  },
+);

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

@@ -0,0 +1,91 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  UnauthorizedError,
+  InternalError,
+  PostApiKeyBody,
+  ApiKeyZod,
+  IPaginatedApiKeys,
+  PaginationOptionsZod,
+  BadRequestError,
+  apiKeyIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const apiKeysContract = c.router(
+  {
+    postApiKey: {
+      summary: '[ADMIN] Create API Key',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostApiKeyBody,
+      responses: {
+        201: ApiKeyZod,
+        400: BadRequestError,
+        404: NotFoundError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getApiKeys: {
+      summary: '[ADMIN] Get API Keys',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod,
+      responses: {
+        200: IPaginatedApiKeys,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getApiKey: {
+      summary: '[ADMIN] Get API Key',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: apiKeyIdSchema,
+      }),
+      responses: {
+        200: ApiKeyZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    deactivateApiKey: {
+      summary: 'Deactivate API Key by id',
+      method: 'PATCH',
+      path: '/:id/deactivate',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: apiKeyIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        202: ApiKeyZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'api-keys',
+  },
+);